@skylord123/node-red-pebble-timeline 1.1.0 → 1.3.0

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@skylord123/node-red-pebble-timeline",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Node-RED nodes for interacting with the Pebble Timeline API",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/skylord123/node-red-pebble-timeline.git"
+  },
   "keywords": [
     "node-red",
     "pebble",

package/pebble-timeline-add.js

@@ -1,6 +1,7 @@
 const axios = require('axios');
 const fs = require('fs-extra');
 const path = require('path');
+const { pinValid } = require('./pebble-timeline-validation');
 
 /**
  * Node-RED node for adding pins to the Pebble Timeline API
@@ -259,67 +260,111 @@ module.exports = function(RED) {
                 }
 
                 // Use overrides if provided, otherwise use config node values
-                const apiUrl = `${apiUrlOverride || configNode.apiUrl}/v1/user/pins/${pin.id}`;
+                const baseApiUrl = apiUrlOverride || configNode.apiUrl;
                 const timelineToken = tokenOverride || configNode.credentials.timelineToken;
 
-                if (!timelineToken) {
-                    const errMsg = "Timeline token is required";
-                    node.status({fill: "red", shape: "dot", text: "Missing token"});
-                    // Only use done callback for errors, don't include error in message
-                    if (done) done(errMsg);
-                    return;
-                }
-
-                // Debug: Log final pin data
-                node.debug(`Sending pin: ${JSON.stringify(pin, null, 2)}`);
-                node.debug(`API URL: ${apiUrl}`);
+                // Check if we're in local emulation mode (empty API URL)
+                const isLocalMode = !baseApiUrl || baseApiUrl.trim() === '';
 
-                // Final validation of the pin object
-                validatePin(pin, node);
+                if (isLocalMode) {
+                    // Local emulation mode - validate and store locally
+                    node.debug(`Local emulation mode - validating pin locally`);
+                    node.debug(`Pin data: ${JSON.stringify(pin, null, 2)}`);
 
-                axios.put(apiUrl, pin, {
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'X-User-Token': timelineToken
-                    }
-                })
-                    .then(response => {
-                        // Set successful status - using "OK" as requested
-                        node.status({fill: "green", shape: "dot", text: "OK"});
+                    // Validate the pin using local validation
+                    const validationResult = pinValid(pin.id, pin);
 
-                        // Store the pin in our local storage
-                        storePin(pin, timelineToken);
+                    if (!validationResult.valid) {
+                        const errMsg = `Pin validation failed: ${validationResult.error}`;
+                        node.status({fill: "red", shape: "dot", text: "Validation failed"});
+                        node.error(errMsg, msg);
 
-                        // Prepare the output message
                         msg.payload = {
-                            success: true,
-                            pin: pin,
-                            response: response.data
+                            success: false,
+                            error: errMsg,
+                            validationError: validationResult.error
                         };
 
                         send(msg);
                         if (done) done();
-                    })
-                    .catch(error => {
-                        // Set error status
-                        node.status({fill: "red", shape: "dot", text: "Error: " + (error.response ? error.response.status : error.message)});
+                        return;
+                    }
 
-                        // Debug: Log detailed error information
-                        if (error.response) {
-                            node.debug(`Error response: ${JSON.stringify(error.response.data)}`);
-                        }
+                    // Pin is valid - store it locally
+                    node.status({fill: "green", shape: "dot", text: "OK (local)"});
+                    storePin(pin, timelineToken || 'local');
 
-                        // Prepare error output without throwing an error to done callback
-                        msg.payload = {
-                            success: false,
-                            error: error.message,
-                            response: error.response ? error.response.data : null
-                        };
+                    msg.payload = {
+                        success: true,
+                        pin: pin,
+                        mode: 'local',
+                        message: 'Pin validated and stored locally'
+                    };
 
-                        send(msg);
-                        // Don't use done callback for errors from API, as we're handling them in the output
-                        if (done) done();
-                    });
+                    send(msg);
+                    if (done) done();
+                } else {
+                    // Remote API mode
+                    const apiUrl = `${baseApiUrl}/v1/user/pins/${pin.id}`;
+
+                    if (!timelineToken) {
+                        const errMsg = "Timeline token is required";
+                        node.status({fill: "red", shape: "dot", text: "Missing token"});
+                        if (done) done(errMsg);
+                        return;
+                    }
+
+                    // Debug: Log final pin data
+                    node.debug(`Sending pin: ${JSON.stringify(pin, null, 2)}`);
+                    node.debug(`API URL: ${apiUrl}`);
+
+                    // Final validation of the pin object
+                    validatePin(pin, node);
+
+                    axios.put(apiUrl, pin, {
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'X-User-Token': timelineToken
+                        }
+                    })
+                        .then(response => {
+                            // Set successful status - using "OK" as requested
+                            node.status({fill: "green", shape: "dot", text: "OK"});
+
+                            // Store the pin in our local storage
+                            storePin(pin, timelineToken);
+
+                            // Prepare the output message
+                            msg.payload = {
+                                success: true,
+                                pin: pin,
+                                response: response.data
+                            };
+
+                            send(msg);
+                            if (done) done();
+                        })
+                        .catch(error => {
+                            // Set error status
+                            node.status({fill: "red", shape: "dot", text: "Error: " + (error.response ? error.response.status : error.message)});
+
+                            // Debug: Log detailed error information
+                            if (error.response) {
+                                node.debug(`Error response: ${JSON.stringify(error.response.data)}`);
+                            }
+
+                            // Prepare error output without throwing an error to done callback
+                            msg.payload = {
+                                success: false,
+                                error: error.message,
+                                response: error.response ? error.response.data : null
+                            };
+
+                            send(msg);
+                            // Don't use done callback for errors from API, as we're handling them in the output
+                            if (done) done();
+                        });
+                }
             } catch (err) {
                 // For unexpected errors, use both the done callback and send the error
                 node.status({fill: "red", shape: "dot", text: "Error: " + err.message});

package/pebble-timeline-config.html

@@ -3,7 +3,7 @@
         category: 'config',
         defaults: {
             name: { value: "" },
-            apiUrl: { value: "https://timeline-api.rebble.io", required: true }
+            apiUrl: { value: "https://timeline-api.rebble.io", required: false }
         },
         credentials: {
             timelineToken: { type: "password" }
@@ -25,6 +25,8 @@
         <input type="text" id="node-config-input-apiUrl" placeholder="https://timeline-api.rebble.io">
         <div class="form-tips">The URL of the Pebble Timeline API. The default URL (https://timeline-api.rebble.io) is
             provided by the Rebble service which maintains Pebble functionality after official support ended.
+            <strong>Leave this field empty to emulate the timeline service locally</strong> - pins will be validated and stored
+            locally without sending requests to a remote server.
         </div>
     </div>
     <div class="form-row">
@@ -46,7 +48,9 @@
 
         <dt>API URL <span class="property-type">string</span></dt>
         <dd>The URL of the Pebble Timeline API. Defaults to https://timeline-api.rebble.io, which is the Rebble service
-            that maintains Pebble functionality.
+            that maintains Pebble functionality. <strong>Leave this field empty to emulate the timeline service locally</strong> -
+            when empty, pins will be validated and stored locally without sending requests to a remote server. This is useful
+            for testing or offline operation.
         </dd>
 
         <dt>Timeline Token <span class="property-type">string</span></dt>

package/pebble-timeline-delete.js

@@ -84,69 +84,95 @@ module.exports = function(RED) {
                 })
             ]).then(() => {
                 // Use overrides if provided, otherwise use config node values
-                const apiUrl = `${node.apiUrlOverride || configNode.apiUrl}/v1/user/pins/${pinId}`;
+                const baseApiUrl = node.apiUrlOverride || configNode.apiUrl;
                 const timelineToken = node.tokenOverride || configNode.credentials.timelineToken;
 
-                if (!timelineToken) {
-                    node.error("Timeline token is required", msg);
-                    if (done) done("Timeline token is required");
-                    return;
-                }
+                // Check if we're in local emulation mode (empty API URL)
+                const isLocalMode = !baseApiUrl || baseApiUrl.trim() === '';
 
-                axios.delete(apiUrl, {
-                    headers: {
-                        'X-User-Token': timelineToken
-                    }
-                })
-                .then(response => {
-                    node.status({fill: "green", shape: "dot", text: "Pin deleted"});
+                if (isLocalMode) {
+                    // Local emulation mode - delete from local storage only
+                    node.debug(`Local emulation mode - deleting pin locally`);
 
                     // Remove the pin from our local storage
-                    removePin(pinId, timelineToken);
+                    removePin(pinId, timelineToken || 'local');
+
+                    node.status({fill: "green", shape: "dot", text: "Pin deleted (local)"});
 
-                    // Prepare the output message
                     msg.payload = {
                         success: true,
                         pinId: pinId,
-                        response: response.data
+                        mode: 'local',
+                        message: 'Pin deleted from local storage'
                     };
 
                     send(msg);
                     if (done) done();
-                })
-                .catch(error => {
-                    // Handle 404 - pin already deleted
-                    if (error.response && error.response.status === 404) {
-                        node.warn(`Pin ${pinId} not found on server (404) - assuming already deleted`);
-                        node.status({fill: "yellow", shape: "dot", text: "Pin already deleted"});
+                } else {
+                    // Remote API mode
+                    const apiUrl = `${baseApiUrl}/v1/user/pins/${pinId}`;
+
+                    if (!timelineToken) {
+                        node.error("Timeline token is required", msg);
+                        if (done) done("Timeline token is required");
+                        return;
+                    }
+
+                    axios.delete(apiUrl, {
+                        headers: {
+                            'X-User-Token': timelineToken
+                        }
+                    })
+                    .then(response => {
+                        node.status({fill: "green", shape: "dot", text: "Pin deleted"});
 
-                        // Remove from local storage anyway
+                        // Remove the pin from our local storage
                         removePin(pinId, timelineToken);
 
+                        // Prepare the output message
                         msg.payload = {
                             success: true,
                             pinId: pinId,
-                            alreadyDeleted: true,
-                            message: "Pin not found on server, removed from local storage"
+                            response: response.data
                         };
 
                         send(msg);
                         if (done) done();
-                    } else {
-                        // Other errors
-                        node.status({fill: "red", shape: "dot", text: "Error: " + (error.response ? error.response.status : error.message)});
-
-                        msg.payload = {
-                            success: false,
-                            pinId: pinId,
-                            error: error.message,
-                            response: error.response ? error.response.data : null
-                        };
-
-                        send(msg);
-                        if (done) done(error);
-                    }
-                });
+                    })
+                    .catch(error => {
+                        // Handle 404 - pin already deleted
+                        if (error.response && error.response.status === 404) {
+                            node.warn(`Pin ${pinId} not found on server (404) - assuming already deleted`);
+                            node.status({fill: "yellow", shape: "dot", text: "Pin already deleted"});
+
+                            // Remove from local storage anyway
+                            removePin(pinId, timelineToken);
+
+                            msg.payload = {
+                                success: true,
+                                pinId: pinId,
+                                alreadyDeleted: true,
+                                message: "Pin not found on server, removed from local storage"
+                            };
+
+                            send(msg);
+                            if (done) done();
+                        } else {
+                            // Other errors
+                            node.status({fill: "red", shape: "dot", text: "Error: " + (error.response ? error.response.status : error.message)});
+
+                            msg.payload = {
+                                success: false,
+                                pinId: pinId,
+                                error: error.message,
+                                response: error.response ? error.response.data : null
+                            };
+
+                            send(msg);
+                            if (done) done(error);
+                        }
+                    });
+                }
             }).catch(err => {
                 if (done) done(err);
             });

package/pebble-timeline-validation.js

@@ -0,0 +1,145 @@
+/**
+ * Local validation module for Pebble Timeline pins
+ * Based on the validation logic from rebble-timeline-sync
+ * https://github.com/pebble-dev/rebble-timeline-sync
+ */
+
+const ISO_FORMAT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/;
+const ISO_FORMAT_MSEC = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+/**
+ * Parse ISO 8601 time string
+ * @param {string} timeStr - ISO 8601 formatted time string
+ * @returns {Date} Parsed date object
+ */
+function parseTime(timeStr) {
+    if (!timeStr || typeof timeStr !== 'string') {
+        throw new Error('Invalid time string');
+    }
+    
+    if (!ISO_FORMAT.test(timeStr) && !ISO_FORMAT_MSEC.test(timeStr)) {
+        throw new Error('Time must be in ISO 8601 format');
+    }
+    
+    const date = new Date(timeStr);
+    if (isNaN(date.getTime())) {
+        throw new Error('Invalid date');
+    }
+    
+    return date;
+}
+
+/**
+ * Validate that a time is within acceptable range
+ * Time must not be more than two days in the past, or a year in the future
+ * @param {Date} time - Date object to validate
+ * @returns {boolean} True if time is valid
+ */
+function timeValid(time) {
+    const now = new Date();
+    const twoDaysAgo = new Date(now.getTime() - (2 * 24 * 60 * 60 * 1000));
+    const oneYearFromNow = new Date(now.getTime() + (366 * 24 * 60 * 60 * 1000));
+    
+    if (time < twoDaysAgo || time > oneYearFromNow) {
+        return false;
+    }
+    
+    return true;
+}
+
+/**
+ * Validate a timeline pin
+ * Based on pin_valid from rebble-timeline-sync/timeline_sync/utils.py
+ * @param {string} pinId - The pin ID from the URL/request
+ * @param {object} pinJson - The pin object to validate
+ * @returns {object} Object with valid (boolean) and error (string) properties
+ */
+function pinValid(pinId, pinJson) {
+    try {
+        // Check that pin JSON exists
+        if (!pinJson || typeof pinJson !== 'object') {
+            return { valid: false, error: 'parse_failure_or_missing_pin' };
+        }
+        
+        // Check that pin ID matches
+        if (pinJson.id !== pinId) {
+            return { valid: false, error: 'id_mismatch' };
+        }
+        
+        // Validate main pin time
+        if (!pinJson.time) {
+            return { valid: false, error: 'missing_time' };
+        }
+        
+        let pinTime;
+        try {
+            pinTime = parseTime(pinJson.time);
+        } catch (e) {
+            return { valid: false, error: 'invalid_time_format' };
+        }
+        
+        if (!timeValid(pinTime)) {
+            return { valid: false, error: 'invalid_time' };
+        }
+        
+        // Validate createNotification - should NOT have a time attribute
+        if (pinJson.createNotification && pinJson.createNotification.time) {
+            return { valid: false, error: 'invalid_time_attribute' };
+        }
+        
+        // Validate updateNotification time if present
+        if (pinJson.updateNotification && pinJson.updateNotification.time) {
+            let updateTime;
+            try {
+                updateTime = parseTime(pinJson.updateNotification.time);
+            } catch (e) {
+                return { valid: false, error: 'invalid_update_notification_time_format' };
+            }
+            
+            if (!timeValid(updateTime)) {
+                return { valid: false, error: 'invalid_time_for_update' };
+            }
+        }
+        
+        // Validate reminders
+        if (pinJson.reminders) {
+            if (!Array.isArray(pinJson.reminders)) {
+                return { valid: false, error: 'reminders_not_array' };
+            }
+            
+            if (pinJson.reminders.length > 3) {
+                return { valid: false, error: 'too_many_reminders' };
+            }
+            
+            for (let i = 0; i < pinJson.reminders.length; i++) {
+                const reminder = pinJson.reminders[i];
+                if (!reminder.time) {
+                    return { valid: false, error: `reminder_${i}_missing_time` };
+                }
+                
+                let reminderTime;
+                try {
+                    reminderTime = parseTime(reminder.time);
+                } catch (e) {
+                    return { valid: false, error: `reminder_${i}_invalid_time_format` };
+                }
+                
+                if (!timeValid(reminderTime)) {
+                    return { valid: false, error: 'invalid_reminder_time' };
+                }
+            }
+        }
+        
+        return { valid: true };
+        
+    } catch (error) {
+        return { valid: false, error: 'miscellaneous_failure: ' + error.message };
+    }
+}
+
+module.exports = {
+    pinValid,
+    parseTime,
+    timeValid
+};
+