@mxtommy/kip 3.10.0-beta.8 → 3.10.0

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+# v 3.10.0
+# New Feature
+* Remote Control Plugin: Instantly switch dashboards on any KIP from any KIP (or your phone). Perfect for mast displays, hard‑to‑reach screens, and non‑touch devices. Open Actions → Settings → Remote Control, pick a device, tap a dashboard—done. Enable remote control in Options → Display → Remote Control.
+# Improvements
+* Added Kiosk Mode setup guide to Help
 # v 3.9.0
 # New Feature
 * A new dashboard navigation experience. Introducing our all-new Dashboard sidenav designed for speed. Effortlessly jump between dashboards with a single tap, always knowing exactly where you are thanks to clear highlighting of your current dashboard.

package/README.md

@@ -122,6 +122,17 @@ For example, Signal K will notify KIP when a water depth or temperature sensor r
 ## Multiple User Profiles
 If you have different roles on board: captain, skipper, tactician, navigator, engineer—or simply different people with different needs, each can tailor KIP as they wish. The use of profiles also allows you to tie specific configuration arrangements to use cases or device form factors.
 
+## Remote Control Other KIP Displays
+Control which dashboard is shown on another KIP instance (e.g., a mast display, hard-to-reach screen, or a non‑touch device) from any KIP, including your phone.
+
+Use cases
+- Mast display: change dashboards from the cockpit.
+- Wall/helm screens: toggle dashboards without standing up or reaching for controls.
+- Non‑touch/no input: select dashboards when no keyboard/mouse is connected or touch is not supported/disabled.
+
+## Dedicated Fullscreen instrument display (Kiosk Mode)
+Runs KIP on Raspberry Pi as a single application full-screen, suppresses desktop UI and stays on screen like a dedicated instrument display at a fraction of the cost. Read the [Kiosk Mode](https://github.com/mxtommy/Kip/blob/master/src/assets/help-docs/kiosk.md) help file.
+
 ## Complementary Components
 Typical complementary components you may install (many are often bundled with Signal K distributions):
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxtommy/kip",
-  "version": "3.10.0-beta.8",
+  "version": "3.10.0",
   "description": "An advanced and versatile marine instrumentation package to display Signal K data.",
   "license": "MIT",
   "author": {
@@ -25,6 +25,7 @@
   "keywords": [
     "signalk-webapp",
     "signalk-category-instruments",
+    "signalk-category-notifications",
     "signalk-node-server-plugin",
     "signal k",
     "signalk",

package/plugin/index.js

@@ -1,50 +1,257 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (app) => {
-    const displaysPath = 'displays';
-    const context = 'vessels.self';
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    function displayPutHandler(context, path, value, callback) {
-        app.debug(`PUT handler called for context ${context}, path ${path}, value ${value}`);
-        try {
-            const delta = {
-                updates: [
-                    {
-                        values: [
-                            {
-                                path: path,
-                                value: value
-                            }
-                        ]
-                    }
-                ]
-            };
-            app.debug(`Sending message: `, JSON.stringify(delta));
-            app.handleMessage(plugin.id, delta);
-            return { state: "COMPLETED", statusCode: 200 };
-        }
-        catch (error) {
-            app.error(`Error in PUT handler: ${error}`);
-            return { state: "COMPLETED", statusCode: 400, message: error.message };
-        }
+const server_api_1 = require("@signalk/server-api");
+const openapi = __importStar(require("./openApi.json"));
+exports.default = (server) => {
+    const API_PATHS = {
+        DISPLAYS: `/displays`,
+        INSTANCE: `/displays/:displayId`,
+        ACTIVE_SCREEN: `/displays/:displayId/activeScreen`
+    };
+    // Helpers
+    function getDisplaySelfPath(displayId, suffix) {
+        const tail = suffix ? `.${suffix}` : '';
+        const want = `displays.${displayId}${tail}`;
+        const full = server.getSelfPath(want);
+        server.debug(`getDisplaySelfPath: displayId: ${displayId}, suffix: ${suffix}, want=${want}, fullPath=${JSON.stringify(full)}`);
+        return full ? full : undefined;
+    }
+    function getAvailableDisplays() {
+        const fullPath = server.getSelfPath('displays');
+        server.debug(`getAvailableDisplays: fullPath=${JSON.stringify(fullPath)}`);
+        return fullPath ? fullPath : undefined;
+    }
+    function pathToDotNotation(path) {
+        const dottedPath = path.replace(/\//g, '.').replace(/^\./, '');
+        server.debug(`pathToDotNotation: input path=${path}, dottedPath=${dottedPath}`);
+        return dottedPath;
+    }
+    function sendOk(res, body) {
+        if (body === undefined)
+            return res.status(204).end();
+        return res.status(200).json(body);
+    }
+    function sendFail(res, statusCode, message) {
+        return res.status(statusCode).json({ state: 'FAILED', statusCode, message });
     }
     const plugin = {
         id: 'kip',
         name: 'KIP',
         description: 'KIP server plugin',
         start: (settings) => {
-            app.debug(`Starting plugin with settings: ${JSON.stringify(settings)}`);
-            app.registerPutHandler(context, displaysPath, displayPutHandler);
+            server.debug(`Starting plugin with settings: ${JSON.stringify(settings)}`);
+            server.setPluginStatus(`Starting...`);
         },
         stop: () => {
-            app.debug(`Stopping plugin`);
+            server.debug(`Stopping plugin`);
+            const msg = 'Stopped.';
+            server.setPluginStatus(msg);
         },
         schema: () => {
             return {
                 type: "object",
                 properties: {}
             };
-        }
+        },
+        registerWithRouter(router) {
+            server.debug(`Registering plugin routes: ${API_PATHS.DISPLAYS}, ${API_PATHS.INSTANCE}, ${API_PATHS.ACTIVE_SCREEN}`);
+            // Validate/normalize :displayId where present
+            router.param('displayId', (req, res, next, displayId) => {
+                if (displayId == null)
+                    return sendFail(res, 400, 'Missing displayId parameter');
+                try {
+                    let id = String(displayId);
+                    // Decode percent-encoding if present
+                    try {
+                        id = decodeURIComponent(id);
+                    }
+                    catch {
+                        // ignore decode errors, keep original id
+                    }
+                    // If someone sent JSON as the path segment, try to recover {"displayId":"..."}
+                    if (id.trim().startsWith('{')) {
+                        try {
+                            const parsed = JSON.parse(id);
+                            if (parsed && typeof parsed.displayId === 'string') {
+                                id = parsed.displayId;
+                            }
+                            else {
+                                return sendFail(res, 400, 'Invalid displayId format in JSON');
+                            }
+                        }
+                        catch {
+                            return sendFail(res, 400, 'Invalid displayId JSON');
+                        }
+                    }
+                    // Basic safety: allow UUID-like strings (alphanum + dash)
+                    if (!/^[A-Za-z0-9-]+$/.test(id)) {
+                        return sendFail(res, 400, 'Invalid displayId format');
+                    }
+                    req.displayId = id;
+                    next();
+                }
+                catch {
+                    return sendFail(res, 400, 'Missing or invalid displayId parameter');
+                }
+            });
+            router.put(`${API_PATHS.INSTANCE}`, async (req, res) => {
+                server.debug(`** PUT ${API_PATHS.INSTANCE}. Params: ${JSON.stringify(req.params)} Body: ${JSON.stringify(req.body)}`);
+                try {
+                    const dottedPath = pathToDotNotation(req.path);
+                    server.debug(`Updating SK path ${dottedPath}`);
+                    server.handleMessage(plugin.id, {
+                        updates: [
+                            {
+                                values: [
+                                    {
+                                        path: dottedPath,
+                                        value: req.body ?? null
+                                    }
+                                ]
+                            }
+                        ]
+                    }, server_api_1.SKVersion.v1);
+                    return res.status(200).json({ state: 'SUCCESS', statusCode: 200 });
+                }
+                catch (error) {
+                    const msg = `HandleMessage failed with errors!`;
+                    server.setPluginError(msg);
+                    server.error(`Error in HandleMessage: ${error}`);
+                    return sendFail(res, 400, error.message);
+                }
+            });
+            router.put(`${API_PATHS.ACTIVE_SCREEN}`, async (req, res) => {
+                server.debug(`** PUT ${API_PATHS.ACTIVE_SCREEN}. Params: ${JSON.stringify(req.params)} Body: ${JSON.stringify(req.body)}`);
+                try {
+                    const dottedPath = pathToDotNotation(req.path);
+                    server.debug(`Updating SK path ${dottedPath} with body.screenIdx`);
+                    server.handleMessage(plugin.id, {
+                        updates: [
+                            {
+                                values: [
+                                    {
+                                        path: dottedPath,
+                                        value: req.body.screenIdx !== undefined ? req.body.screenIdx : null
+                                    }
+                                ]
+                            }
+                        ]
+                    }, server_api_1.SKVersion.v1);
+                    return res.status(200).json({ state: 'SUCCESS', statusCode: 200 });
+                }
+                catch (error) {
+                    const msg = `HandleMessage failed with errors!`;
+                    server.setPluginError(msg);
+                    server.error(`Error in HandleMessage: ${error}`);
+                    return sendFail(res, 400, error.message);
+                }
+            });
+            router.get(API_PATHS.DISPLAYS, (req, res) => {
+                server.debug(`** GET ${API_PATHS.DISPLAYS}. Params: ${JSON.stringify(req.params)}`);
+                try {
+                    const displays = getAvailableDisplays();
+                    const items = displays && typeof displays === 'object'
+                        ? Object.entries(displays)
+                            .filter(([, v]) => v && typeof v === 'object')
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            .map(([displayId, v]) => ({
+                            displayId,
+                            displayName: v?.value?.displayName ?? null
+                        }))
+                        : [];
+                    server.debug(`getAvailableDisplays returned: ${JSON.stringify(displays)}`);
+                    server.debug(`Found ${items.length} displays: ${JSON.stringify(items)}`);
+                    return res.status(200).json(items);
+                }
+                catch (error) {
+                    server.error(`Error reading displays: ${String(error.message || error)}`);
+                    return sendFail(res, 400, error.message);
+                }
+            });
+            router.get(`${API_PATHS.INSTANCE}`, (req, res) => {
+                server.debug(`** GET ${API_PATHS.INSTANCE}. Params: ${JSON.stringify(req.params)}`);
+                try {
+                    const displayId = req.displayId;
+                    if (!displayId) {
+                        return sendFail(res, 400, 'Missing displayId parameter');
+                    }
+                    const node = getDisplaySelfPath(displayId);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const screens = node?.value?.screens ?? null;
+                    if (screens === undefined) {
+                        return sendFail(res, 404, `Display ${displayId} not found`);
+                    }
+                    return sendOk(res, screens);
+                }
+                catch (error) {
+                    server.error(`Error reading display ${req.params?.displayId}: ${String(error.message || error)}`);
+                    return sendFail(res, 400, error.message);
+                }
+            });
+            router.get(`${API_PATHS.ACTIVE_SCREEN}`, (req, res) => {
+                server.debug(`** GET ${API_PATHS.ACTIVE_SCREEN}. Params: ${JSON.stringify(req.params)}`);
+                try {
+                    const displayId = req.displayId;
+                    if (!displayId) {
+                        return sendFail(res, 400, 'Missing displayId parameter');
+                    }
+                    const node = getDisplaySelfPath(displayId, 'activeScreen');
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const idx = node?.value ?? null;
+                    if (idx === undefined) {
+                        return sendFail(res, 404, `Active screen for display ${displayId} not found`);
+                    }
+                    return sendOk(res, idx);
+                }
+                catch (error) {
+                    server.error(`Error reading activeScreen for ${req.params?.displayId}: ${String(error.message || error)}`);
+                    return sendFail(res, 400, error.message);
+                }
+            });
+            // List all registered routes for debugging
+            if (router.stack) {
+                router.stack.forEach((layer) => {
+                    if (layer.route && layer.route.path) {
+                        server.debug(`Registered route: ${layer.route.stack[0].method.toUpperCase()} ${layer.route.path}`);
+                    }
+                });
+            }
+            server.setPluginStatus(`Providing remote display screen control`);
+        },
+        getOpenApi: () => openapi
     };
     return plugin;
 };