@skylord123/node-red-pebble-timeline 1.1.0 → 1.4.0-beta.1

package/.github/workflows/publish.yml

@@ -0,0 +1,81 @@
+name: Publish to npm
+
+# Publishes the package to npm whenever a GitHub Release is published.
+# It publishes the exact commit the release tag points to, so a pre-release
+# can be cut from any branch (e.g. a beta off `dev`) without that branch
+# having to be merged into master first.
+#
+# The release tag is the source of truth for the version:
+#   - Stable tag (e.g. v1.2.3)             -> published to the "latest"
+#                                             dist-tag; the version bump is
+#                                             committed back to master.
+#   - Pre-release tag (e.g. v1.2.3-beta.1) -> published to a matching dist-tag
+#                                             ("beta", "rc", ...); does NOT
+#                                             become "latest" and is NOT
+#                                             committed back to master.
+#
+# Authentication uses npm Trusted Publishing (OIDC) - no token or secret is
+# needed. Configure a trusted publisher for this package on npmjs.com:
+#   Repository: skylord123/node-red-pebble-timeline
+#   Workflow:   publish.yml
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write   # commit the version bump back to master
+      id-token: write   # npm Trusted Publishing (OIDC) + provenance
+    steps:
+      - name: Check out the released commit
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org
+
+      - name: Update npm
+        # Trusted Publishing requires npm 11.5.1 or newer; Node 22 ships npm 10.
+        run: npm install -g npm@latest
+
+      - name: Determine version and dist-tag
+        id: ver
+        run: |
+          VERSION="${GITHUB_REF_NAME#v}"
+          if [[ "$VERSION" == *-* ]]; then
+            # pre-release, e.g. 1.0.0-beta.1 -> dist-tag "beta"
+            DIST_TAG="${VERSION#*-}"
+            DIST_TAG="${DIST_TAG%%.*}"
+            PRERELEASE=true
+          else
+            DIST_TAG=latest
+            PRERELEASE=false
+          fi
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "dist_tag=$DIST_TAG" >> "$GITHUB_OUTPUT"
+          echo "prerelease=$PRERELEASE" >> "$GITHUB_OUTPUT"
+          echo "Publishing $VERSION to npm dist-tag '$DIST_TAG' (prerelease=$PRERELEASE)"
+
+      - name: Set version
+        run: npm version "${{ steps.ver.outputs.version }}" --no-git-tag-version --allow-same-version
+
+      - name: Publish to npm
+        run: npm publish --provenance --access public --tag "${{ steps.ver.outputs.dist_tag }}"
+
+      - name: Commit version bump back to master
+        if: steps.ver.outputs.prerelease == 'false'
+        run: |
+          if git diff --quiet; then
+            echo "package.json already at ${{ steps.ver.outputs.version }}; nothing to commit."
+            exit 0
+          fi
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git commit -am "Set version to ${{ steps.ver.outputs.version }}"
+          git push origin HEAD:master \
+            || echo "::warning::Could not push the version bump to master (branch protection?). The package was still published."

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@skylord123/node-red-pebble-timeline",
-  "version": "1.1.0",
+  "version": "1.4.0-beta.1",
   "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",
@@ -23,5 +27,3 @@
     "fs-extra": "^11.1.0"
   }
 }
-
-

package/pebble-timeline-add.js

@@ -1,6 +1,6 @@
 const axios = require('axios');
-const fs = require('fs-extra');
-const path = require('path');
+const { pinValid } = require('./pebble-timeline-validation');
+const store = require('./pebble-timeline-store');
 
 /**
  * Node-RED node for adding pins to the Pebble Timeline API
@@ -28,20 +28,7 @@ module.exports = function(RED) {
             return;
         }
 
-        // Make sure storage directory exists
-        const storageDir = path.join(RED.settings.userDir, 'pebble-timeline');
-        fs.ensureDirSync(storageDir);
-        const pinsFile = path.join(storageDir, 'timeline-pins.json');
-
-        // Load existing pins (organized by token)
-        let pinsData = {};
-        try {
-            if (fs.existsSync(pinsFile)) {
-                pinsData = JSON.parse(fs.readFileSync(pinsFile, 'utf8'));
-            }
-        } catch (error) {
-            node.warn(`Error loading pins file: ${error.message}`);
-        }
+        store.init(RED.settings.userDir);
 
         node.on('input', async function(msg, send, done) {
             // Backwards compatibility with Node-RED 0.x
@@ -259,67 +246,119 @@ 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;
+                    }
+
+                    // Pin is valid - store it locally
+                    try {
+                        await store.addPin(store.resolveKey(configNode, tokenOverride), pin);
+                    } catch (e) {
+                        node.warn(`Error saving pin to local storage: ${e.message}`);
+                    }
+                    node.status({fill: "green", shape: "dot", text: "OK (local)"});
+
+                    msg.payload = {
+                        success: true,
+                        pin: pin,
+                        mode: 'local',
+                        message: 'Pin validated and stored locally'
+                    };
+
+                    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 detailed error information
-                        if (error.response) {
-                            node.debug(`Error response: ${JSON.stringify(error.response.data)}`);
+                    // 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(async response => {
+                            // Store the pin in our local storage
+                            try {
+                                await store.addPin(store.resolveKey(configNode, tokenOverride), pin);
+                            } catch (e) {
+                                node.warn(`Error saving pin to local storage: ${e.message}`);
+                            }
 
-                        // Prepare error output without throwing an error to done callback
-                        msg.payload = {
-                            success: false,
-                            error: error.message,
-                            response: error.response ? error.response.data : null
-                        };
+                            // Set successful status - using "OK" as requested
+                            node.status({fill: "green", shape: "dot", text: "OK"});
+
+                            // 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)}`);
+                            }
 
-                        send(msg);
-                        // Don't use done callback for errors from API, as we're handling them in the output
-                        if (done) done();
-                    });
+                            // 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});
@@ -335,82 +374,6 @@ module.exports = function(RED) {
             }
         });
 
-        // Helper to store a pin in local storage
-        function storePin(pin, timelineToken) {
-            // Ensure we have a valid token
-            if (!timelineToken) {
-                node.warn("Cannot store pin: No valid timeline token provided");
-                return;
-            }
-
-            // Convert token to string to ensure it can be used as an object key
-            timelineToken = String(timelineToken);
-
-            // Initialize the token's pins array if it doesn't exist
-            if (!pinsData[timelineToken]) {
-                pinsData[timelineToken] = [];
-            }
-
-            // Remove any existing pin with the same ID for this token
-            pinsData[timelineToken] = pinsData[timelineToken].filter(p => p.id !== pin.id);
-
-            // Add the new pin with a timestamp for when it was added
-            pinsData[timelineToken].push({
-                ...pin,
-                _stored: new Date().toISOString()
-            });
-
-            // Clean up old pins (older than 1 month) from all tokens
-            cleanupOldPins();
-
-            // Write the pins to the file
-            try {
-                fs.writeFileSync(pinsFile, JSON.stringify(pinsData, null, 2));
-            } catch (error) {
-                node.warn(`Error saving pins to file: ${error.message}`);
-            }
-        }
-
-        // Helper to clean up pins older than 1 month
-        function cleanupOldPins() {
-            const oneMonthAgo = new Date();
-            oneMonthAgo.setMonth(oneMonthAgo.getMonth() - 1);
-            let changed = false;
-
-            // Iterate through all tokens
-            Object.keys(pinsData).forEach(token => {
-                // Make sure the token's data is an array
-                if (!Array.isArray(pinsData[token])) {
-                    pinsData[token] = [];
-                    return;
-                }
-
-                // Filter out pins older than 1 month
-                const initialCount = pinsData[token].length;
-                pinsData[token] = pinsData[token].filter(pin => {
-                    // Make sure pin has _stored property
-                    if (!pin || !pin._stored) return false;
-
-                    try {
-                        const storedDate = new Date(pin._stored);
-                        return storedDate >= oneMonthAgo;
-                    } catch (e) {
-                        // If date parsing fails, remove the pin
-                        return false;
-                    }
-                });
-
-                // Log if pins were removed
-                if (pinsData[token].length < initialCount) {
-                    node.debug(`Removed ${initialCount - pinsData[token].length} old pins for token ${token.substring(0, 8)}...`);
-                    changed = true;
-                }
-            });
-
-            // No need to save here as the calling function will save the file
-            return changed;
-        }
-
         // Apply node configuration to the pin
         async function applyNodeConfiguration(pin, config, msg, node) {
             try {

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

@@ -1,41 +1,26 @@
 const axios = require('axios');
-const fs = require('fs-extra');
-const path = require('path');
+const store = require('./pebble-timeline-store');
 
 module.exports = function(RED) {
     function PebbleTimelineDeleteNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
-        // Get the config node
         const configNode = RED.nodes.getNode(config.config);
         if (!configNode) {
             node.error("No Pebble Timeline configuration found");
             return;
         }
 
-        // Make sure storage directory exists
-        const storageDir = path.join(RED.settings.userDir, 'pebble-timeline');
-        fs.ensureDirSync(storageDir);
-        const pinsFile = path.join(storageDir, 'timeline-pins.json');
-
-        // Load existing pins (organized by token)
-        let pinsData = {};
-        try {
-            if (fs.existsSync(pinsFile)) {
-                pinsData = JSON.parse(fs.readFileSync(pinsFile, 'utf8'));
-            }
-        } catch (error) {
-            node.warn(`Error loading pins file: ${error.message}`);
-        }
+        store.init(RED.settings.userDir);
 
         node.on('input', function(msg, send, done) {
-            // Backwards compatibility with Node-RED 0.x
             send = send || function() { node.send.apply(node, arguments) };
 
-            // Get the pin ID to delete
             let pinId;
-            // Process parameters in sequence
+            let apiUrlOverride = null;
+            let tokenOverride = null;
+
             Promise.all([
                 new Promise(resolve => {
                     RED.util.evaluateNodeProperty(config.pinId, config.pinIdType, node, msg, (err, result) => {
@@ -56,12 +41,11 @@ module.exports = function(RED) {
                     });
                 }),
 
-                // Check for server override options
                 new Promise(resolve => {
                     if (config.apiUrl) {
                         RED.util.evaluateNodeProperty(config.apiUrl, config.apiUrlType, node, msg, (err, result) => {
                             if (!err && result) {
-                                node.apiUrlOverride = result;
+                                apiUrlOverride = result;
                             }
                             resolve();
                         });
@@ -74,7 +58,7 @@ module.exports = function(RED) {
                     if (config.token) {
                         RED.util.evaluateNodeProperty(config.token, config.tokenType, node, msg, (err, result) => {
                             if (!err && result) {
-                                node.tokenOverride = result;
+                                tokenOverride = result;
                             }
                             resolve();
                         });
@@ -82,110 +66,106 @@ module.exports = function(RED) {
                         resolve();
                     }
                 })
-            ]).then(() => {
-                // Use overrides if provided, otherwise use config node values
-                const apiUrl = `${node.apiUrlOverride || configNode.apiUrl}/v1/user/pins/${pinId}`;
-                const timelineToken = node.tokenOverride || configNode.credentials.timelineToken;
-
-                if (!timelineToken) {
-                    node.error("Timeline token is required", msg);
-                    if (done) done("Timeline token is required");
-                    return;
-                }
+            ]).then(async () => {
+                const baseApiUrl = apiUrlOverride || configNode.apiUrl;
+                const timelineToken = tokenOverride || configNode.credentials.timelineToken;
+                const storeKey = store.resolveKey(configNode, tokenOverride);
+
+                const isLocalMode = !baseApiUrl || baseApiUrl.trim() === '';
 
-                axios.delete(apiUrl, {
-                    headers: {
-                        'X-User-Token': timelineToken
+                if (isLocalMode) {
+                    node.debug(`Local emulation mode - deleting pin locally`);
+
+                    try {
+                        await store.removePin(storeKey, pinId);
+                    } catch (e) {
+                        node.warn(`Error removing pin from local storage: ${e.message}`);
                     }
-                })
-                .then(response => {
-                    node.status({fill: "green", shape: "dot", text: "Pin deleted"});
 
-                    // Remove the pin from our local storage
-                    removePin(pinId, timelineToken);
+                    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 {
+                    const apiUrl = `${baseApiUrl}/v1/user/pins/${pinId}`;
 
-                        // Remove from local storage anyway
-                        removePin(pinId, timelineToken);
+                    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(async response => {
+                        node.status({fill: "green", shape: "dot", text: "Pin deleted"});
+
+                        try {
+                            await store.removePin(storeKey, pinId);
+                        } catch (e) {
+                            node.warn(`Error removing pin from local storage: ${e.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
-                        };
+                    })
+                    .catch(async error => {
+                        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"});
+
+                            try {
+                                await store.removePin(storeKey, pinId);
+                            } catch (e) {
+                                node.warn(`Error removing pin from local storage: ${e.message}`);
+                            }
 
-                        send(msg);
-                        if (done) done(error);
-                    }
-                });
+                            msg.payload = {
+                                success: true,
+                                pinId: pinId,
+                                alreadyDeleted: true,
+                                message: "Pin not found on server, removed from local storage"
+                            };
+
+                            send(msg);
+                            if (done) done();
+                        } else {
+                            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);
             });
         });
 
-        // Helper to remove a pin from local storage
-        function removePin(pinId, timelineToken) {
-            // Ensure we have a valid token
-            if (!timelineToken) {
-                node.warn("Cannot remove pin: No valid timeline token provided");
-                return;
-            }
-
-            // Convert token to string to ensure it can be used as an object key
-            timelineToken = String(timelineToken);
-
-            // Check if this token has any pins
-            if (!pinsData[timelineToken]) {
-                return; // No pins for this token
-            }
-
-            // Remove the pin with the specified ID from this token's pins
-            const initialCount = pinsData[timelineToken].length;
-            pinsData[timelineToken] = pinsData[timelineToken].filter(p => p.id !== pinId);
-
-            // Note: Cleanup of old pins is handled in the add node
-
-            // Only write if we actually removed something
-            if (pinsData[timelineToken].length !== initialCount) {
-                try {
-                    fs.writeFileSync(pinsFile, JSON.stringify(pinsData, null, 2));
-                } catch (error) {
-                    node.warn(`Error saving pins to file: ${error.message}`);
-                }
-            }
-        }
-
         node.on('close', function() {
-            // Clean up any resources
         });
     }
 

package/pebble-timeline-list.js

@@ -1,25 +1,19 @@
-const fs = require('fs-extra');
-const path = require('path');
+const store = require('./pebble-timeline-store');
 
 module.exports = function(RED) {
     function PebbleTimelineListNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
-        // Get the config node
         const configNode = RED.nodes.getNode(config.config);
         if (!configNode) {
             node.error("No Pebble Timeline configuration found");
             return;
         }
 
-        // Make sure storage directory exists
-        const storageDir = path.join(RED.settings.userDir, 'pebble-timeline');
-        fs.ensureDirSync(storageDir);
-        const pinsFile = path.join(storageDir, 'timeline-pins.json');
+        store.init(RED.settings.userDir);
 
         node.on('input', function(msg, send, done) {
-            // Backwards compatibility with Node-RED 0.x
             send = send || function() { node.send.apply(node, arguments) };
 
             let startTime = null;
@@ -27,7 +21,6 @@ module.exports = function(RED) {
             let apiUrlOverride = null;
             let tokenOverride = null;
 
-            // Process filter parameters in sequence
             Promise.resolve()
                 .then(() => {
                     return new Promise((resolve) => {
@@ -94,58 +87,15 @@ module.exports = function(RED) {
                     });
                 })
                 .then(() => {
-                    // Load the pins
-                    let pinsData = {};
-                    try {
-                        if (fs.existsSync(pinsFile)) {
-                            pinsData = JSON.parse(fs.readFileSync(pinsFile, 'utf8'));
-                        }
-                    } catch (error) {
-                        node.warn(`Error loading pins file: ${error.message}`);
-                    }
-
-                    // Get the timeline token to use
-                    let timelineToken = tokenOverride || configNode.credentials.timelineToken;
-
-                    // Ensure we have a valid token
-                    if (!timelineToken) {
-                        node.warn("No valid timeline token provided");
-                        timelineToken = "default"; // Use a default key to avoid errors
-                    }
+                    const key = store.resolveKey(configNode, tokenOverride);
+                    const pins = store.getPins(key);
 
-                    // Convert token to string to ensure it can be used as an object key
-                    timelineToken = String(timelineToken);
-
-                    // Get pins for this token only
-                    let pins = [];
-                    if (pinsData[timelineToken] && Array.isArray(pinsData[timelineToken])) {
-                        pins = pinsData[timelineToken];
-                    }
-
-                    // Apply filters
                     const filteredPins = pins.filter(pin => {
-                        let include = true;
-
-                        if (startTime !== null) {
-                            const pinTime = new Date(pin.time);
-                            if (pinTime < startTime) {
-                                include = false;
-                            }
-                        }
-
-                        if (endTime !== null) {
-                            const pinTime = new Date(pin.time);
-                            if (pinTime > endTime) {
-                                include = false;
-                            }
-                        }
-
-                        return include;
+                        if (startTime !== null && new Date(pin.time) < startTime) return false;
+                        if (endTime !== null && new Date(pin.time) > endTime) return false;
+                        return true;
                     });
 
-                    // Note: Cleanup of old pins is handled in the add node
-
-                    // Create output message
                     msg.payload = filteredPins;
                     msg.count = filteredPins.length;
 
@@ -161,7 +111,6 @@ module.exports = function(RED) {
         });
 
         node.on('close', function() {
-            // Clean up any resources
         });
     }
 

package/pebble-timeline-store.js

@@ -0,0 +1,93 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+let pinsFile = null;
+let pinsData = null;
+let writeQueue = Promise.resolve();
+
+function init(userDir) {
+    if (pinsFile) return;
+    const storageDir = path.join(userDir, 'pebble-timeline');
+    fs.ensureDirSync(storageDir);
+    pinsFile = path.join(storageDir, 'timeline-pins.json');
+    try {
+        pinsData = fs.existsSync(pinsFile)
+            ? JSON.parse(fs.readFileSync(pinsFile, 'utf8'))
+            : {};
+    } catch (e) {
+        pinsData = {};
+    }
+}
+
+// Compute the storage bucket key for a given config node, preferring the
+// timeline token (or a per-message override) and falling back to the config
+// node's own id so each config is isolated even without a token.
+function resolveKey(configNode, override) {
+    const token = override
+        || (configNode && configNode.credentials && configNode.credentials.timelineToken);
+    if (token) return String(token);
+    if (configNode && configNode.id) return String(configNode.id);
+    return 'local';
+}
+
+function getPins(key) {
+    if (!pinsData) return [];
+    return Array.isArray(pinsData[key]) ? pinsData[key].slice() : [];
+}
+
+function addPin(key, pin) {
+    return enqueue(() => {
+        if (!Array.isArray(pinsData[key])) pinsData[key] = [];
+        pinsData[key] = pinsData[key].filter(p => p.id !== pin.id);
+        pinsData[key].push({ ...pin, _stored: new Date().toISOString() });
+        cleanupOldPins();
+        return writeFile();
+    });
+}
+
+function removePin(key, pinId) {
+    return enqueue(() => {
+        if (!Array.isArray(pinsData[key])) return false;
+        const before = pinsData[key].length;
+        pinsData[key] = pinsData[key].filter(p => p.id !== pinId);
+        if (pinsData[key].length === before) return false;
+        return writeFile().then(() => true);
+    });
+}
+
+// Serialize all mutating operations through a single promise chain so
+// concurrent add/delete invocations cannot race on the read-modify-write.
+function enqueue(fn) {
+    const next = writeQueue.then(fn, fn);
+    writeQueue = next.catch(() => {});
+    return next;
+}
+
+function cleanupOldPins() {
+    const oneMonthAgo = new Date();
+    oneMonthAgo.setMonth(oneMonthAgo.getMonth() - 1);
+    for (const k of Object.keys(pinsData)) {
+        if (!Array.isArray(pinsData[k])) {
+            pinsData[k] = [];
+            continue;
+        }
+        pinsData[k] = pinsData[k].filter(pin => {
+            if (!pin || !pin._stored) return false;
+            const d = new Date(pin._stored);
+            return !isNaN(d.getTime()) && d >= oneMonthAgo;
+        });
+    }
+}
+
+function writeFile() {
+    const tmp = pinsFile + '.tmp';
+    const data = JSON.stringify(pinsData, null, 2);
+    return new Promise((resolve, reject) => {
+        fs.writeFile(tmp, data, (err) => {
+            if (err) return reject(err);
+            fs.rename(tmp, pinsFile, (err2) => err2 ? reject(err2) : resolve());
+        });
+    });
+}
+
+module.exports = { init, resolveKey, getPins, addPin, removePin };

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
+};
+

package/.claude/settings.local.json

@@ -1,11 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(xargs:*)",
-      "Bash(find:*)",
-      "WebSearch",
-      "WebFetch(domain:developer.rebble.io)",
-      "WebFetch(domain:github.com)"
-    ]
-  }
-}

package/node-red-sync-flow.json

@@ -1,124 +0,0 @@
-[
-    {
-        "id": "sync-flow-tab",
-        "type": "tab",
-        "label": "Rebble Timeline Sync",
-        "disabled": false,
-        "info": "Flow to fetch timeline pins from Rebble sync endpoint"
-    },
-    {
-        "id": "inject-token",
-        "type": "inject",
-        "z": "sync-flow-tab",
-        "name": "Set Access Token",
-        "props": [
-            {
-                "p": "access_token",
-                "v": "YOUR_ACCESS_TOKEN_HERE",
-                "vt": "str"
-            }
-        ],
-        "repeat": "",
-        "crontab": "",
-        "once": false,
-        "onceDelay": 0.1,
-        "topic": "",
-        "x": 140,
-        "y": 100,
-        "wires": [
-            ["setup-request"]
-        ]
-    },
-    {
-        "id": "setup-request",
-        "type": "function",
-        "z": "sync-flow-tab",
-        "name": "Setup Request",
-        "func": "msg.url = 'https://timeline-sync.rebble.io/v1/sync';\nmsg.headers = {\n    'Authorization': 'Bearer ' + msg.access_token\n};\n\n// Optional: pass timeline/glance cursor for incremental sync\nif (msg.timeline) {\n    msg.url += '?timeline=' + msg.timeline;\n    if (msg.glance) {\n        msg.url += '&glance=' + msg.glance;\n    }\n} else if (msg.glance) {\n    msg.url += '?glance=' + msg.glance;\n}\n\nreturn msg;",
-        "outputs": 1,
-        "timeout": "",
-        "noerr": 0,
-        "initialize": "",
-        "finalize": "",
-        "libs": [],
-        "x": 340,
-        "y": 100,
-        "wires": [
-            ["http-request"]
-        ]
-    },
-    {
-        "id": "http-request",
-        "type": "http request",
-        "z": "sync-flow-tab",
-        "name": "GET /v1/sync",
-        "method": "GET",
-        "ret": "obj",
-        "paytoqs": "ignore",
-        "url": "",
-        "tls": "",
-        "persist": false,
-        "proxy": "",
-        "insecureHTTPParser": false,
-        "authType": "",
-        "senderr": false,
-        "headers": [],
-        "x": 530,
-        "y": 100,
-        "wires": [
-            ["debug-output", "parse-response"]
-        ]
-    },
-    {
-        "id": "debug-output",
-        "type": "debug",
-        "z": "sync-flow-tab",
-        "name": "Sync Response",
-        "active": true,
-        "tosidebar": true,
-        "console": false,
-        "tostatus": false,
-        "complete": "payload",
-        "targetType": "msg",
-        "statusVal": "",
-        "statusType": "auto",
-        "x": 740,
-        "y": 60,
-        "wires": []
-    },
-    {
-        "id": "parse-response",
-        "type": "function",
-        "z": "sync-flow-tab",
-        "name": "Parse Updates",
-        "func": "// Extract updates array and syncURL for next request\nlet response = msg.payload;\n\nif (response.updates && response.updates.length > 0) {\n    node.status({fill: 'green', shape: 'dot', text: response.updates.length + ' updates'});\n} else {\n    node.status({fill: 'yellow', shape: 'ring', text: 'No updates'});\n}\n\n// Store syncURL for subsequent requests\nmsg.syncURL = response.syncURL;\nmsg.updates = response.updates || [];\n\nreturn msg;",
-        "outputs": 1,
-        "timeout": "",
-        "noerr": 0,
-        "initialize": "",
-        "finalize": "",
-        "libs": [],
-        "x": 740,
-        "y": 140,
-        "wires": [
-            ["debug-updates"]
-        ]
-    },
-    {
-        "id": "debug-updates",
-        "type": "debug",
-        "z": "sync-flow-tab",
-        "name": "Parsed Updates",
-        "active": true,
-        "tosidebar": true,
-        "console": false,
-        "tostatus": false,
-        "complete": "true",
-        "targetType": "full",
-        "statusVal": "",
-        "statusType": "auto",
-        "x": 940,
-        "y": 140,
-        "wires": []
-    }
-]