In browser push notifications by using browser://hello apprise URL

.github/workflows/test-stack-reusable-workflow.yml

@@ -71,6 +71,7 @@ jobs:
           docker run test-changedetectionio  bash -c 'python3 -m unittest changedetectionio.tests.unit.test_watch_model'
           docker run test-changedetectionio  bash -c 'python3 -m unittest changedetectionio.tests.unit.test_jinja2_security'
           docker run test-changedetectionio  bash -c 'python3 -m unittest changedetectionio.tests.unit.test_semver'
+          docker run test-changedetectionio  bash -c 'python3 -m unittest changedetectionio.tests.unit.test_browser_notifications'
 
       - name: Test built container with Pytest (generally as requests/plaintext fetching)
         run: |

changedetectionio/blueprint/browser_notifications/__init__.py

@@ -0,0 +1 @@
+# Browser notifications blueprint

changedetectionio/blueprint/browser_notifications/browser_notifications.py

@@ -0,0 +1,76 @@
+from flask import Blueprint, jsonify, request
+from loguru import logger
+
+
+def construct_blueprint(datastore):
+    browser_notifications_blueprint = Blueprint('browser_notifications', __name__)
+
+    @browser_notifications_blueprint.route("/test", methods=['POST'])
+    def test_browser_notification():
+        """Send a test browser notification using the apprise handler"""
+        try:
+            from changedetectionio.notification.apprise_plugin.custom_handlers import apprise_browser_notification_handler
+
+            # Check if there are any subscriptions
+            browser_subscriptions = datastore.data.get('settings', {}).get('application', {}).get('browser_subscriptions', [])
+            if not browser_subscriptions:
+                return jsonify({'success': False, 'message': 'No browser subscriptions found'}), 404
+
+            # Get notification data from request or use defaults
+            data = request.get_json() or {}
+            title = data.get('title', 'Test Notification')
+            body = data.get('body', 'This is a test notification from changedetection.io')
+
+            # Use the apprise handler directly
+            success = apprise_browser_notification_handler(
+                body=body,
+                title=title,
+                notify_type='info',
+                meta={'url': 'browser://test'}
+            )
+
+            if success:
+                subscription_count = len(browser_subscriptions)
+                return jsonify({
+                    'success': True,
+                    'message': f'Test notification sent successfully to {subscription_count} subscriber(s)'
+                })
+            else:
+                return jsonify({'success': False, 'message': 'Failed to send test notification'}), 500
+
+        except ImportError:
+            logger.error("Browser notification handler not available")
+            return jsonify({'success': False, 'message': 'Browser notification handler not available'}), 500
+        except Exception as e:
+            logger.error(f"Failed to send test browser notification: {e}")
+            return jsonify({'success': False, 'message': f'Error: {str(e)}'}), 500
+
+    @browser_notifications_blueprint.route("/clear", methods=['POST'])
+    def clear_all_browser_notifications():
+        """Clear all browser notification subscriptions from the datastore"""
+        try:
+            # Get current subscription count
+            browser_subscriptions = datastore.data.get('settings', {}).get('application', {}).get('browser_subscriptions', [])
+            subscription_count = len(browser_subscriptions)
+
+            # Clear all subscriptions
+            if 'settings' not in datastore.data:
+                datastore.data['settings'] = {}
+            if 'application' not in datastore.data['settings']:
+                datastore.data['settings']['application'] = {}
+
+            datastore.data['settings']['application']['browser_subscriptions'] = []
+            datastore.needs_write = True
+
+            logger.info(f"Cleared {subscription_count} browser notification subscriptions")
+
+            return jsonify({
+                'success': True, 
+                'message': f'Cleared {subscription_count} browser notification subscription(s)'
+            })
+
+        except Exception as e:
+            logger.error(f"Failed to clear all browser notifications: {e}")
+            return jsonify({'success': False, 'message': f'Clear all failed: {str(e)}'}), 500
+
+    return browser_notifications_blueprint

changedetectionio/flask_app.py

@@ -39,6 +39,11 @@
 from changedetectionio import __version__
 from changedetectionio import queuedWatchMetaData
 from changedetectionio.api import Watch, WatchHistory, WatchSingleHistory, CreateWatch, Import, SystemInfo, Tag, Tags, Notifications, WatchFavicon
+from changedetectionio.notification.BrowserNotifications import (
+    BrowserNotificationsVapidPublicKey,
+    BrowserNotificationsSubscribe, 
+    BrowserNotificationsUnsubscribe
+)
 from changedetectionio.api.Search import Search
 from .time_handler import is_within_schedule
 
@@ -94,6 +99,7 @@
     logger.warning(f"Unable to set locale {default_locale}, locale is not installed maybe?")
 
 watch_api = Api(app, decorators=[csrf.exempt])
+browser_notification_api = Api(app, decorators=[csrf.exempt])
 
 def init_app_secret(datastore_path):
     secret = ""
@@ -336,6 +342,11 @@ def check_authentication():
 
     watch_api.add_resource(Notifications, '/api/v1/notifications',
                            resource_class_kwargs={'datastore': datastore})
+
+    # Browser notification endpoints
+    browser_notification_api.add_resource(BrowserNotificationsVapidPublicKey, '/browser-notifications-api/vapid-public-key')
+    browser_notification_api.add_resource(BrowserNotificationsSubscribe, '/browser-notifications-api/subscribe')
+    browser_notification_api.add_resource(BrowserNotificationsUnsubscribe, '/browser-notifications-api/unsubscribe')
 
     @login_manager.user_loader
     def user_loader(email):
@@ -489,10 +500,29 @@ def static_content(group, filename):
         except FileNotFoundError:
             abort(404)
 
+    @app.route("/service-worker.js", methods=['GET'])
+    def service_worker():
+        from flask import make_response
+        try:
+            # Serve from the changedetectionio/static/js directory
+            static_js_path = os.path.join(os.path.dirname(__file__), 'static', 'js')
+            response = make_response(send_from_directory(static_js_path, "service-worker.js"))
+            response.headers['Content-Type'] = 'application/javascript'
+            response.headers['Service-Worker-Allowed'] = '/'
+            response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
+            response.headers['Pragma'] = 'no-cache'
+            response.headers['Expires'] = '0'
+            return response
+        except FileNotFoundError:
+            abort(404)
+
 
     import changedetectionio.blueprint.browser_steps as browser_steps
     app.register_blueprint(browser_steps.construct_blueprint(datastore), url_prefix='/browser-steps')
 
+    import changedetectionio.blueprint.browser_notifications.browser_notifications as browser_notifications
+    app.register_blueprint(browser_notifications.construct_blueprint(datastore), url_prefix='/browser-notifications')
+
     from changedetectionio.blueprint.imports import construct_blueprint as construct_import_blueprint
     app.register_blueprint(construct_import_blueprint(datastore, update_q, queuedWatchMetaData), url_prefix='/imports')
 

changedetectionio/forms.py

@@ -707,6 +707,7 @@ def __init__(self, formdata=None, obj=None, prefix="", data=None, meta=None, **k
     processor = RadioField( label=u"Processor - What do you want to achieve?", choices=processors.available_processors(), default="text_json_diff")
     timezone = StringField("Timezone for watch schedule", render_kw={"list": "timezones"}, validators=[validateTimeZoneName()])
     webdriver_delay = IntegerField('Wait seconds before extracting text', validators=[validators.Optional(), validators.NumberRange(min=1, message="Should contain one or more seconds")])
+
 
 
 class importForm(Form):

changedetectionio/model/App.py

@@ -66,6 +66,11 @@ class model(dict):
                         'socket_io_enabled': True,
                         'favicons_enabled': True
                     },
+                    'vapid': {
+                        'private_key': None,
+                        'public_key': None,
+                        'contact_email': None
+                    },
                 }
             }
         }

changedetectionio/notification/BrowserNotifications.py

@@ -0,0 +1,217 @@
+import json
+from flask import request, current_app
+from flask_restful import Resource, marshal_with, fields
+from loguru import logger
+
+
+browser_notifications_fields = {
+    'success': fields.Boolean,
+    'message': fields.String,
+}
+
+vapid_public_key_fields = {
+    'publicKey': fields.String,
+}
+
+test_notification_fields = {
+    'success': fields.Boolean,
+    'message': fields.String,
+    'sent_count': fields.Integer,
+}
+
+
+class BrowserNotificationsVapidPublicKey(Resource):
+    """Get VAPID public key for browser push notifications"""
+
+    @marshal_with(vapid_public_key_fields)
+    def get(self):
+        try:
+            from changedetectionio.notification.apprise_plugin.browser_notification_helpers import (
+                get_vapid_config_from_datastore, convert_pem_public_key_for_browser
+            )
+
+            datastore = current_app.config.get('DATASTORE')
+            if not datastore:
+                return {'publicKey': None}, 500
+
+            private_key, public_key_pem, contact_email = get_vapid_config_from_datastore(datastore)
+
+            if not public_key_pem:
+                return {'publicKey': None}, 404
+
+            # Convert PEM format to URL-safe base64 format for browser
+            public_key_b64 = convert_pem_public_key_for_browser(public_key_pem)
+
+            if public_key_b64:
+                return {'publicKey': public_key_b64}
+            else:
+                return {'publicKey': None}, 500
+
+        except Exception as e:
+            logger.error(f"Failed to get VAPID public key: {e}")
+            return {'publicKey': None}, 500
+
+
+class BrowserNotificationsSubscribe(Resource):
+    """Subscribe to browser notifications"""
+
+    @marshal_with(browser_notifications_fields)
+    def post(self):
+        try:
+            data = request.get_json()
+            if not data:
+                return {'success': False, 'message': 'No data provided'}, 400
+
+            subscription = data.get('subscription')
+
+            if not subscription:
+                return {'success': False, 'message': 'Subscription is required'}, 400
+
+            # Validate subscription format
+            required_fields = ['endpoint', 'keys']
+            for field in required_fields:
+                if field not in subscription:
+                    return {'success': False, 'message': f'Missing subscription field: {field}'}, 400
+
+            if 'p256dh' not in subscription['keys'] or 'auth' not in subscription['keys']:
+                return {'success': False, 'message': 'Missing subscription keys'}, 400
+
+            # Get datastore
+            datastore = current_app.config.get('DATASTORE')
+            if not datastore:
+                return {'success': False, 'message': 'Datastore not available'}, 500
+
+            # Initialize browser_subscriptions if it doesn't exist
+            if 'browser_subscriptions' not in datastore.data['settings']['application']:
+                datastore.data['settings']['application']['browser_subscriptions'] = []
+
+            # Check if subscription already exists
+            existing_subscriptions = datastore.data['settings']['application']['browser_subscriptions']
+            for existing_sub in existing_subscriptions:
+                if existing_sub.get('endpoint') == subscription.get('endpoint'):
+                    return {'success': True, 'message': 'Already subscribed to browser notifications'}
+
+            # Add new subscription
+            datastore.data['settings']['application']['browser_subscriptions'].append(subscription)
+            datastore.needs_write = True
+
+            logger.info(f"New browser notification subscription: {subscription.get('endpoint')}")
+
+            return {'success': True, 'message': 'Successfully subscribed to browser notifications'}
+
+        except Exception as e:
+            logger.error(f"Failed to subscribe to browser notifications: {e}")
+            return {'success': False, 'message': f'Subscription failed: {str(e)}'}, 500
+
+
+class BrowserNotificationsUnsubscribe(Resource):
+    """Unsubscribe from browser notifications"""
+
+    @marshal_with(browser_notifications_fields)
+    def post(self):
+        try:
+            data = request.get_json()
+            if not data:
+                return {'success': False, 'message': 'No data provided'}, 400
+
+            subscription = data.get('subscription')
+
+            if not subscription or not subscription.get('endpoint'):
+                return {'success': False, 'message': 'Valid subscription is required'}, 400
+
+            # Get datastore
+            datastore = current_app.config.get('DATASTORE')
+            if not datastore:
+                return {'success': False, 'message': 'Datastore not available'}, 500
+
+            # Check if subscriptions exist
+            browser_subscriptions = datastore.data.get('settings', {}).get('application', {}).get('browser_subscriptions', [])
+            if not browser_subscriptions:
+                return {'success': True, 'message': 'No subscriptions found'}
+
+            # Remove subscription with matching endpoint
+            endpoint = subscription.get('endpoint')
+            original_count = len(browser_subscriptions)
+
+            datastore.data['settings']['application']['browser_subscriptions'] = [
+                sub for sub in browser_subscriptions 
+                if sub.get('endpoint') != endpoint
+            ]
+
+            removed_count = original_count - len(datastore.data['settings']['application']['browser_subscriptions'])
+
+            if removed_count > 0:
+                datastore.needs_write = True
+                logger.info(f"Removed {removed_count} browser notification subscription(s)")
+                return {'success': True, 'message': 'Successfully unsubscribed from browser notifications'}
+            else:
+                return {'success': True, 'message': 'No matching subscription found'}
+
+        except Exception as e:
+            logger.error(f"Failed to unsubscribe from browser notifications: {e}")
+            return {'success': False, 'message': f'Unsubscribe failed: {str(e)}'}, 500
+
+
+
+class BrowserNotificationsTest(Resource):
+    """Send a test browser notification"""
+
+    @marshal_with(test_notification_fields)
+    def post(self):
+        try:
+            data = request.get_json()
+            if not data:
+                return {'success': False, 'message': 'No data provided', 'sent_count': 0}, 400
+
+            title = data.get('title', 'Test Notification')
+            body = data.get('body', 'This is a test notification from changedetection.io')
+
+            # Get datastore to check if subscriptions exist
+            datastore = current_app.config.get('DATASTORE')
+            if not datastore:
+                return {'success': False, 'message': 'Datastore not available', 'sent_count': 0}, 500
+
+            # Check if there are subscriptions before attempting to send
+            browser_subscriptions = datastore.data.get('settings', {}).get('application', {}).get('browser_subscriptions', [])
+            if not browser_subscriptions:
+                return {'success': False, 'message': 'No subscriptions found', 'sent_count': 0}, 404
+
+            # Use the apprise handler directly
+            try:
+                from changedetectionio.notification.apprise_plugin.custom_handlers import apprise_browser_notification_handler
+
+                # Call the apprise handler with test data
+                success = apprise_browser_notification_handler(
+                    body=body,
+                    title=title,
+                    notify_type='info',
+                    meta={'url': 'browser://test'}
+                )
+
+                # Count how many subscriptions we have after sending (some may have been removed if invalid)
+                final_subscriptions = datastore.data.get('settings', {}).get('application', {}).get('browser_subscriptions', [])
+                sent_count = len(browser_subscriptions)  # Original count
+
+                if success:
+                    return {
+                        'success': True,
+                        'message': f'Test notification sent successfully to {sent_count} subscriber(s)',
+                        'sent_count': sent_count
+                    }
+                else:
+                    return {
+                        'success': False,
+                        'message': 'Failed to send test notification',
+                        'sent_count': 0
+                    }, 500
+
+            except ImportError:
+                return {'success': False, 'message': 'Browser notification handler not available', 'sent_count': 0}, 500
+
+        except Exception as e:
+            logger.error(f"Failed to send test browser notification: {e}")
+            return {'success': False, 'message': f'Test failed: {str(e)}', 'sent_count': 0}, 500
+
+
+
+