update dependencies incl. electron to v41 (#4058)

- update to electron v41
- update other deps
- add missing `globals` dep, see
https://github.com/MagicMirrorOrg/MagicMirror/pull/4057#issuecomment-4049058107

.github/workflows/automated-tests.yaml

@@ -18,7 +18,7 @@ concurrency:
 
 jobs:
   code-style-check:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     timeout-minutes: 15
     steps:
       - name: "Checkout code"
@@ -42,7 +42,7 @@ jobs:
     timeout-minutes: 30
     strategy:
       matrix:
-        node-version: [22.21.1, 22.x, 24.x]
+        node-version: [22.x, 24.x, 25.x]
     steps:
       - name: Install electron dependencies and labwc
         run: |
@@ -69,7 +69,7 @@ jobs:
           sudo chmod 4755 ./node_modules/electron/dist/chrome-sandbox
           # Start labwc
           WLR_BACKENDS=headless WLR_LIBINPUT_NO_DEVICES=1 WLR_RENDERER=pixman labwc &
-          touch css/custom.css
+          touch config/custom.css
       - name: "Run tests"
         run: |
           export WAYLAND_DISPLAY=wayland-0

.github/workflows/dep-review.yaml

@@ -10,7 +10,7 @@ permissions:
 
 jobs:
   dependency-review:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     steps:
       - name: "Checkout code"
         uses: actions/checkout@v6

.github/workflows/electron-rebuild.yaml

@@ -5,10 +5,10 @@ on: [pull_request]
 jobs:
   rebuild:
     name: Run electron-rebuild
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     strategy:
       matrix:
-        node-version: [22.21.1, 22.x, 24.x]
+        node-version: [22.x, 24.x, 25.x]
     steps:
       - name: Checkout code
         uses: actions/checkout@v6

.github/workflows/enforce-pullrequest-rules.yaml

@@ -12,7 +12,7 @@ on:
 
 jobs:
   check:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     if: github.event_name == 'pull_request'
     timeout-minutes: 10
     steps:

.github/workflows/release-notes.yaml

@@ -15,7 +15,7 @@ concurrency:
 
 jobs:
   release-notes:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     timeout-minutes: 15
     steps:
       - name: "Checkout code"

.github/workflows/spellcheck.yaml

@@ -12,7 +12,7 @@ permissions:
 
 jobs:
   spellcheck:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     steps:
       - name: Checkout code
         uses: actions/checkout@v6

.github/workflows/stale.yaml

@@ -10,7 +10,7 @@ permissions:
 
 jobs:
   stale:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     steps:
       - uses: actions/stale@v10
         with:

.gitignore

@@ -54,20 +54,13 @@ Temporary Items
 .directory
 .Trash-*
 
-# Ignore all modules except the default modules.
+# Ignore all modules
 /modules/*
-!/modules/default
 
-# Ignore changes to the custom css files but keep the sample and main.
-/css/*
-!/css/custom.css.sample
-!/css/font-awesome.css
-!/css/main.css
-!/css/roboto.css
-
-# Ignore users config file but keep the sample.
+# Ignore users config file but keep the samples.
 config
 !config/config.js.sample
+!config/custom.css.sample
 
 # Vim
 ## swap

Collaboration.md

@@ -46,6 +46,7 @@ Are done by
   - [ ] add label `mastermerge`
   - [ ] title of the PR is `Release 2.xx.0`
   - [ ] description of the PR is the body of the draft release with name `v2.xx.0`
+- [ ] check if new PR has merge conflicts, if so, merge `master` into the new PR and solve the conflicts
 - [ ] after PR tests run without issues, merge PR
 - [ ] edit draft release with name `v2.xx.0`
   - [ ] set corresponding version tag `v2.xx.0` (with `Select tag` and then `Create new tag`)
@@ -61,11 +62,24 @@ Are done by
 
 ### After release
 
-- [ ] publish release notes with link to github release on forum in new locked topic
+- [ ] publish release notes with link to github release on forum in new locked topic (use edit release on github to copy the content with markdown syntax)
 - [ ] close all issues with label `ready (coming with next release)`
 - [ ] release new documentation by merging `develop` on `master` in documentation repository
 - [ ] publish new version on [npm](https://www.npmjs.com/package/magicmirror)
   - [ ] use a clean environment (e.g. container)
   - [ ] clone this repository with the new `master` branch and `cd` into the local repository directory
-  - [ ] log in to npm with `npm login --auth-type legacy` which will ask for username and password and one-time-password which is sent via mail
-  - [ ] execute `npm publish`
+  - [ ] **Method 1 (recommended): With browser and 2FA**
+    - [ ] execute `npm login` which will open a browser window
+    - [ ] log in with your npm credentials and enter your 2FA code
+    - [ ] execute `npm publish`
+  - [ ] **Method 2 (fallback for headless environments): With token (bypasses 2FA)**
+    - [ ] ⚠️ Note: This method bypasses 2FA and should only be used when a browser is not available
+    - [ ] goto `https://www.npmjs.com/settings/<username>/tokens/` and click `generate new token`
+    - [ ] enable `Bypass two-factor authentication (2FA)` and under `Packages and scopes` give `Read and write` permission to the `magicmirror` package, press `Generate token`
+    - [ ] execute:
+
+      ```bash
+      NPM_TOKEN="npm_xxxxxx"
+      npm set "//registry.npmjs.org/:_authToken=$NPM_TOKEN"
+      npm publish
+      ```

README.md

@@ -51,5 +51,10 @@ If we receive enough donations we might even be able to free up some working hou
 To donate, please follow [this](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=G5D8E9MR5DTD2&source=url) link.
 
 <p style="text-align: center">
-  <a href="https://forum.magicmirror.builders/topic/728/magicmirror-is-voted-number-1-in-the-magpi-top-50"><img src="https://magicmirror.builders/img/magpi-best-watermark-custom.png" width="150" alt="MagPi Top 50"></a>
+  <a href="https://forum.magicmirror.builders/topic/728/magicmirror-is-voted-number-1-in-the-magpi-top-50">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://magicmirror.builders/img/magpi-best-watermark.png">
+      <img src="https://magicmirror.builders/img/magpi-best-watermark-custom.png" width="150" alt="MagPi Top 50">
+    </picture>
+  </a>
 </p>

clientonly/index.js

@@ -1,136 +1,167 @@
 "use strict";
 
-// Use separate scope to prevent global scope pollution
-(function () {
+const http = require("node:http");
+const https = require("node:https");
+
+/**
+ * Get command line parameters
+ * Assumes that a cmdline parameter is defined with `--key [value]`
+ *
+ * example: `node clientonly --address localhost --port 8080 --use-tls`
+ * @param {string} key key to look for at the command line
+ * @param {string} defaultValue value if no key is given at the command line
+ * @returns {string} the value of the parameter
+ */
+function getCommandLineParameter (key, defaultValue = undefined) {
+	const index = process.argv.indexOf(`--${key}`);
+	const value = index > -1 ? process.argv[index + 1] : undefined;
+	return value !== undefined ? String(value) : defaultValue;
+}
+
+/**
+ * Helper function to get server address/hostname from either the commandline or env
+ * @returns {object} config object containing address, port, and tls properties
+ */
+function getServerParameters () {
 	const config = {};
 
-	/**
-	 * Helper function to get server address/hostname from either the commandline or env
-	 */
-	function getServerAddress () {
+	// Prefer command line arguments over environment variables
+	config.address = getCommandLineParameter("address", process.env.ADDRESS);
+	const portValue = getCommandLineParameter("port", process.env.PORT);
+	config.port = portValue ? parseInt(portValue, 10) : undefined;
 
-		/**
-		 * Get command line parameters
-		 * Assumes that a cmdline parameter is defined with `--key [value]`
-		 * @param {string} key key to look for at the command line
-		 * @param {string} defaultValue value if no key is given at the command line
-		 * @returns {string} the value of the parameter
-		 */
-		function getCommandLineParameter (key, defaultValue = undefined) {
-			const index = process.argv.indexOf(`--${key}`);
-			const value = index > -1 ? process.argv[index + 1] : undefined;
-			return value !== undefined ? String(value) : defaultValue;
-		}
+	// determine if "--use-tls"-flag was provided
+	config.tls = process.argv.includes("--use-tls");
 
-		// Prefer command line arguments over environment variables
-		["address", "port"].forEach((key) => {
-			config[key] = getCommandLineParameter(key, process.env[key.toUpperCase()]);
-		});
+	return config;
+}
 
-		// determine if "--use-tls"-flag was provided
-		config.tls = process.argv.indexOf("--use-tls") > 0;
-	}
+/**
+ * Gets the config from the specified server url
+ * @param {string} url location where the server is running.
+ * @returns {Promise} the config
+ */
+function getServerConfig (url) {
+	// Return new pending promise
+	return new Promise((resolve, reject) => {
+		// Select http or https module, depending on requested url
+		const lib = url.startsWith("https") ? https : http;
+		const request = lib.get(url, (response) => {
+			let configData = "";
 
-	/**
-	 * Gets the config from the specified server url
-	 * @param {string} url location where the server is running.
-	 * @returns {Promise} the config
-	 */
-	function getServerConfig (url) {
-		// Return new pending promise
-		return new Promise((resolve, reject) => {
-			// Select http or https module, depending on requested url
-			const lib = url.startsWith("https") ? require("node:https") : require("node:http");
-			const request = lib.get(url, (response) => {
-				let configData = "";
-
-				// Gather incoming data
-				response.on("data", function (chunk) {
-					configData += chunk;
-				});
-				// Resolve promise at the end of the HTTP/HTTPS stream
-				response.on("end", function () {
+			// Gather incoming data
+			response.on("data", function (chunk) {
+				configData += chunk;
+			});
+			// Resolve promise at the end of the HTTP/HTTPS stream
+			response.on("end", function () {
+				try {
 					resolve(JSON.parse(configData));
-				});
-			});
-
-			request.on("error", function (error) {
-				reject(new Error(`Unable to read config from server (${url} (${error.message}`));
+				} catch (parseError) {
+					reject(new Error(`Failed to parse server response as JSON: ${parseError.message}`));
+				}
 			});
 		});
-	}
 
-	/**
-	 * Print a message to the console in case of errors
-	 * @param {string} message error message to print
-	 * @param {number} code error code for the exit call
-	 */
-	function fail (message, code = 1) {
-		if (message !== undefined && typeof message === "string") {
-			console.log(message);
-		} else {
-			console.log("Usage: 'node clientonly --address 192.168.1.10 --port 8080 [--use-tls]'");
-		}
-		process.exit(code);
-	}
+		request.on("error", function (error) {
+			reject(new Error(`Unable to read config from server (${url}) (${error.message})`));
+		});
+	});
+}
 
-	getServerAddress();
-
-	(config.address && config.port) || fail();
-	const prefix = config.tls ? "https://" : "http://";
-
-	// Only start the client if a non-local server was provided
-	if (["localhost", "127.0.0.1", "::1", "::ffff:127.0.0.1", undefined].indexOf(config.address) === -1) {
-		getServerConfig(`${prefix}${config.address}:${config.port}/config/`)
-			.then(function (configReturn) {
-				// check environment for DISPLAY or WAYLAND_DISPLAY
-				const elecParams = ["js/electron.js"];
-				if (process.env.WAYLAND_DISPLAY) {
-					console.log(`Client: Using WAYLAND_DISPLAY=${process.env.WAYLAND_DISPLAY}`);
-					elecParams.push("--enable-features=UseOzonePlatform");
-					elecParams.push("--ozone-platform=wayland");
-				} else if (process.env.DISPLAY) {
-					console.log(`Client: Using DISPLAY=${process.env.DISPLAY}`);
-				} else {
-					fail("Error: Requires environment variable WAYLAND_DISPLAY or DISPLAY, none is provided.");
-				}
-				// Pass along the server config via an environment variable
-				const env = Object.create(process.env);
-				env.clientonly = true; // set to pass to electron.js
-				const options = { env: env };
-				configReturn.address = config.address;
-				configReturn.port = config.port;
-				configReturn.tls = config.tls;
-				env.config = JSON.stringify(configReturn);
-
-				// Spawn electron application
-				const electron = require("electron");
-				const child = require("node:child_process").spawn(electron, elecParams, options);
-
-				// Pipe all child process output to current stdout
-				child.stdout.on("data", function (buf) {
-					process.stdout.write(`Client: ${buf}`);
-				});
-
-				// Pipe all child process errors to current stderr
-				child.stderr.on("data", function (buf) {
-					process.stderr.write(`Client: ${buf}`);
-				});
-
-				child.on("error", function (err) {
-					process.stdout.write(`Client: ${err}`);
-				});
-
-				child.on("close", (code) => {
-					if (code !== 0) {
-						console.log(`There something wrong. The clientonly is not running code ${code}`);
-					}
-				});
-			})
-			.catch(function (reason) {
-				fail(`Unable to connect to server: (${reason})`);
-			});
+/**
+ * Print a message to the console in case of errors
+ * @param {string} message error message to print
+ * @param {number} code error code for the exit call
+ */
+function fail (message, code = 1) {
+	if (message !== undefined && typeof message === "string") {
+		console.error(message);
 	} else {
-		fail();
+		console.error("Usage: 'node clientonly --address 192.168.1.10 --port 8080 [--use-tls]'");
 	}
-}());
+	process.exit(code);
+}
+
+/**
+ * Starts the client by connecting to the server and launching the Electron application
+ * @param {object} config server configuration
+ * @param {string} prefix http or https prefix
+ * @async
+ */
+async function startClient (config, prefix) {
+	try {
+		const serverUrl = `${prefix}${config.address}:${config.port}/config/`;
+		console.log(`Client: Connecting to server at ${serverUrl}`);
+		const configReturn = await getServerConfig(serverUrl);
+		console.log("Client: Successfully retrieved config from server");
+
+		// check environment for DISPLAY or WAYLAND_DISPLAY
+		const elecParams = ["js/electron.js"];
+		if (process.env.WAYLAND_DISPLAY) {
+			console.log(`Client: Using WAYLAND_DISPLAY=${process.env.WAYLAND_DISPLAY}`);
+			elecParams.push("--enable-features=UseOzonePlatform");
+			elecParams.push("--ozone-platform=wayland");
+		} else if (process.env.DISPLAY) {
+			console.log(`Client: Using DISPLAY=${process.env.DISPLAY}`);
+		} else {
+			fail("Error: Requires environment variable WAYLAND_DISPLAY or DISPLAY, none is provided.");
+		}
+
+		// Pass along the server config via an environment variable
+		const env = { ...process.env };
+		env.clientonly = true;
+		const options = { env: env };
+		configReturn.address = config.address;
+		configReturn.port = config.port;
+		configReturn.tls = config.tls;
+		env.config = JSON.stringify(configReturn);
+
+		// Spawn electron application
+		const electron = require("electron");
+		const child = require("node:child_process").spawn(electron, elecParams, options);
+
+		// Pipe all child process output to current stdout
+		child.stdout.on("data", function (buf) {
+			process.stdout.write(`Client: ${buf}`);
+		});
+
+		// Pipe all child process errors to current stderr
+		child.stderr.on("data", function (buf) {
+			process.stderr.write(`Client: ${buf}`);
+		});
+
+		child.on("error", function (err) {
+			process.stderr.write(`Client: ${err}`);
+		});
+
+		child.on("close", (code) => {
+			if (code !== 0) {
+				fail(`There is something wrong. The clientonly process exited with code ${code}.`);
+			}
+		});
+	} catch (reason) {
+		fail(`Unable to connect to server: (${reason})`);
+	}
+}
+
+// Main execution
+const config = getServerParameters();
+const prefix = config.tls ? "https://" : "http://";
+
+// Validate port
+if (config.port !== undefined && (isNaN(config.port) || config.port < 1 || config.port > 65535)) {
+	fail(`Invalid port number: ${config.port}. Port must be between 1 and 65535.`);
+}
+
+// Only start the client if a non-local server was provided and address/port are set
+const LOCAL_ADDRESSES = ["localhost", "127.0.0.1", "::1", "::ffff:127.0.0.1"];
+if (
+	config.address
+	&& config.port
+	&& !LOCAL_ADDRESSES.includes(config.address)
+) {
+	startClient(config, prefix);
+} else {
+	fail();
+}

cspell.config.json

@@ -179,6 +179,7 @@
 		"Lightspeed",
 		"loadingcircle",
 		"locationforecast",
+		"logg",
 		"lockstring",
 		"lstrip",
 		"Luciella",
@@ -247,6 +248,7 @@
 		"Reis",
 		"rejas",
 		"relativehumidity",
+		"resultstring",
 		"Resig",
 		"roboto",
 		"rohitdharavath",
@@ -285,6 +287,9 @@
 		"Teeuw",
 		"Teil",
 		"TESTMODE",
+		"testpass",
+		"testuser",
+		"teststring",
 		"thomasrockhu",
 		"thumbslider",
 		"timeformat",
@@ -307,6 +312,7 @@
 		"VEVENT",
 		"vgtu",
 		"Vitest",
+		"VCALENDAR",
 		"Voelt",
 		"Vorberechnung",
 		"vppencilsharpener",
@@ -326,6 +332,7 @@
 		"winddirection",
 		"windgusts",
 		"windspeed",
+		"WKST",
 		"Woolridge",
 		"worktree",
 		"Wsymb",
@@ -343,11 +350,11 @@
 	"ignorePaths": [
 		"css/roboto.css",
 		"node_modules/**",
-		"modules/!(default)/**",
-		"modules/default/**/translations/!(en).json",
-		"modules/default/calendar/windowsZones.json",
-		"modules/default/clock/faces/*.svg",
-		"modules/default/weather/providers/yr.js",
+		"modules/**",
+		"defaultmodules/**/translations/!(en).json",
+		"defaultmodules/calendar/windowsZones.json",
+		"defaultmodules/clock/faces/*.svg",
+		"defaultmodules/weather/providers/yr.js",
 		"tests/mocks/**",
 		"tests/e2e/modules/clock_es_spec.js",
 		"translations/**"

defaultmodules/calendar/calendar.js

@@ -169,9 +169,7 @@ Module.register("calendar", {
 
 	notificationReceived (notification, payload, sender) {
 		if (notification === "FETCH_CALENDAR") {
-			if (this.hasCalendarURL(payload.url)) {
-				this.sendSocketNotification(notification, { url: payload.url, id: this.identifier });
-			}
+			this.sendSocketNotification(notification, { url: payload.url, id: this.identifier });
 		}
 	},
 
@@ -183,40 +181,38 @@ Module.register("calendar", {
 		}
 
 		if (notification === "CALENDAR_EVENTS") {
-			if (this.hasCalendarURL(payload.url)) {
-				// have we received events for this url
-				if (!this.calendarData[payload.url]) {
-					// no, setup the structure to hold the info
-					this.calendarData[payload.url] = { events: null, checksum: null };
-				}
-				// save the event list
-				this.calendarData[payload.url].events = payload.events;
+			// have we received events for this url
+			if (!this.calendarData[payload.url]) {
+				// no, setup the structure to hold the info
+				this.calendarData[payload.url] = { events: null, checksum: null };
+			}
+			// save the event list
+			this.calendarData[payload.url].events = payload.events;
 
-				this.error = null;
-				this.loaded = true;
+			this.error = null;
+			this.loaded = true;
 
-				if (this.config.broadcastEvents) {
-					this.broadcastEvents();
-				}
-				// if the checksum is the same
-				if (this.calendarData[payload.url].checksum === payload.checksum) {
-					// then don't update the UI
-					return;
-				}
-				// haven't seen or the checksum is different
-				this.calendarData[payload.url].checksum = payload.checksum;
+			if (this.config.broadcastEvents) {
+				this.broadcastEvents();
+			}
+			// if the checksum is the same
+			if (this.calendarData[payload.url].checksum === payload.checksum) {
+				// then don't update the UI
+				return;
+			}
+			// haven't seen or the checksum is different
+			this.calendarData[payload.url].checksum = payload.checksum;
 
-				if (!this.config.updateOnFetch) {
-					if (this.calendarDisplayer[payload.url] === undefined) {
-						// calendar will never displayed, so display it
-						this.updateDom(this.config.animationSpeed);
-						// set this calendar as displayed
-						this.calendarDisplayer[payload.url] = true;
-					} else {
-						Log.debug("[calendar] DOM not updated waiting self update()");
-					}
-					return;
+			if (!this.config.updateOnFetch) {
+				if (this.calendarDisplayer[payload.url] === undefined) {
+					// calendar will never displayed, so display it
+					this.updateDom(this.config.animationSpeed);
+					// set this calendar as displayed
+					this.calendarDisplayer[payload.url] = true;
+				} else {
+					Log.debug("[calendar] DOM not updated waiting self update()");
 				}
+				return;
 			}
 		} else if (notification === "CALENDAR_ERROR") {
 			let error_message = this.translate(payload.error_type);
@@ -580,21 +576,6 @@ Module.register("calendar", {
 		return wrapper;
 	},
 
-	/**
-	 * Checks if this config contains the calendar url.
-	 * @param {string} url The calendar url
-	 * @returns {boolean} True if the calendar config contains the url, False otherwise
-	 */
-	hasCalendarURL (url) {
-		for (const calendar of this.config.calendars) {
-			if (calendar.url === url) {
-				return true;
-			}
-		}
-
-		return false;
-	},
-
 	/**
 	 * converts the given timestamp to a moment with a timezone
 	 * @param {number} timestamp timestamp from an event

defaultmodules/calendar/calendarfetcher.js

@@ -0,0 +1,129 @@
+const ical = require("node-ical");
+const Log = require("logger");
+const { Agent } = require("undici");
+const CalendarFetcherUtils = require("./calendarfetcherutils");
+const HTTPFetcher = require("#http_fetcher");
+
+/**
+ * CalendarFetcher - Fetches and parses iCal calendar data
+ * Uses HTTPFetcher for HTTP handling with intelligent error handling
+ * @class
+ */
+class CalendarFetcher {
+
+	/**
+	 * Creates a new CalendarFetcher instance
+	 * @param {string} url - The URL of the calendar to fetch
+	 * @param {number} reloadInterval - Time in ms between fetches
+	 * @param {string[]} excludedEvents - Event titles to exclude
+	 * @param {number} maximumEntries - Maximum number of events to return
+	 * @param {number} maximumNumberOfDays - Maximum days in the future to fetch
+	 * @param {object} auth - Authentication options {method: 'basic'|'bearer', user, pass}
+	 * @param {boolean} includePastEvents - Whether to include past events
+	 * @param {boolean} selfSignedCert - Whether to accept self-signed certificates
+	 */
+	constructor (url, reloadInterval, excludedEvents, maximumEntries, maximumNumberOfDays, auth, includePastEvents, selfSignedCert) {
+		this.url = url;
+		this.excludedEvents = excludedEvents;
+		this.maximumEntries = maximumEntries;
+		this.maximumNumberOfDays = maximumNumberOfDays;
+		this.includePastEvents = includePastEvents;
+
+		this.events = [];
+		this.lastFetch = null;
+		this.fetchFailedCallback = () => {};
+		this.eventsReceivedCallback = () => {};
+
+		// Use HTTPFetcher for HTTP handling (Composition)
+		this.httpFetcher = new HTTPFetcher(url, {
+			reloadInterval,
+			auth,
+			selfSignedCert
+		});
+
+		// Wire up HTTPFetcher events
+		this.httpFetcher.on("response", (response) => this.#handleResponse(response));
+		this.httpFetcher.on("error", (errorInfo) => this.fetchFailedCallback(this, errorInfo));
+	}
+
+	/**
+	 * Handles successful HTTP response
+	 * @param {Response} response - The fetch Response object
+	 */
+	async #handleResponse (response) {
+		try {
+			const responseData = await response.text();
+			const parsed = ical.parseICS(responseData);
+
+			Log.debug(`Parsed iCal data from ${this.url} with ${Object.keys(parsed).length} entries.`);
+
+			this.events = CalendarFetcherUtils.filterEvents(parsed, {
+				excludedEvents: this.excludedEvents,
+				includePastEvents: this.includePastEvents,
+				maximumEntries: this.maximumEntries,
+				maximumNumberOfDays: this.maximumNumberOfDays
+			});
+
+			this.lastFetch = Date.now();
+			this.broadcastEvents();
+		} catch (error) {
+			Log.error(`${this.url} - iCal parsing failed: ${error.message}`);
+			this.fetchFailedCallback(this, {
+				message: `iCal parsing failed: ${error.message}`,
+				status: null,
+				errorType: "PARSE_ERROR",
+				translationKey: "MODULE_ERROR_UNSPECIFIED",
+				retryAfter: this.httpFetcher.reloadInterval,
+				retryCount: 0,
+				url: this.url,
+				originalError: error
+			});
+		}
+	}
+
+	/**
+	 * Starts fetching calendar data
+	 */
+	fetchCalendar () {
+		this.httpFetcher.startPeriodicFetch();
+	}
+
+	/**
+	 * Check if enough time has passed since the last fetch to warrant a new one.
+	 * Uses reloadInterval as the threshold to respect user's configured fetchInterval.
+	 * @returns {boolean} True if a new fetch should be performed
+	 */
+	shouldRefetch () {
+		if (!this.lastFetch) {
+			return true;
+		}
+		const timeSinceLastFetch = Date.now() - this.lastFetch;
+		return timeSinceLastFetch >= this.httpFetcher.reloadInterval;
+	}
+
+	/**
+	 * Broadcasts the current events to listeners
+	 */
+	broadcastEvents () {
+		Log.info(`Broadcasting ${this.events.length} events from ${this.url}.`);
+		this.eventsReceivedCallback(this);
+	}
+
+	/**
+	 * Sets the callback for successful event fetches
+	 * @param {(fetcher: CalendarFetcher) => void} callback - Called when events are received
+	 */
+	onReceive (callback) {
+		this.eventsReceivedCallback = callback;
+	}
+
+	/**
+	 * Sets the callback for fetch failures
+	 * @param {(fetcher: CalendarFetcher, error: Error) => void} callback - Called when a fetch fails
+	 */
+	onError (callback) {
+		this.fetchFailedCallback = callback;
+	}
+}
+
+module.exports = CalendarFetcher;

defaultmodules/calendar/calendarfetcherutils.js

@@ -0,0 +1,276 @@
+/**
+ * @external Moment
+ */
+const moment = require("moment-timezone");
+const ical = require("node-ical");
+
+const Log = require("logger");
+
+const CalendarFetcherUtils = {
+
+	/**
+	 * Determine based on the title of an event if it should be excluded from the list of events
+	 * @param {object} config the global config
+	 * @param {string} title the title of the event
+	 * @returns {object} excluded: true if the event should be excluded, false otherwise
+	 * until: the date until the event should be excluded.
+	 */
+	shouldEventBeExcluded (config, title) {
+		for (const filterConfig of config.excludedEvents) {
+			const match = CalendarFetcherUtils.checkEventAgainstFilter(title, filterConfig);
+			if (match) {
+				return {
+					excluded: !match.until,
+					until: match.until
+				};
+			}
+		}
+
+		return {
+			excluded: false,
+			until: null
+		};
+	},
+
+	/**
+	 * Get local timezone.
+	 * This method makes it easier to test if different timezones cause problems by changing this implementation.
+	 * @returns {string} timezone
+	 */
+	getLocalTimezone () {
+		return moment.tz.guess();
+	},
+
+	/**
+	 * Filter the events from ical according to the given config
+	 * @param {object} data the calendar data from ical
+	 * @param {object} config The configuration object
+	 * @returns {object[]} the filtered events
+	 */
+	filterEvents (data, config) {
+		const newEvents = [];
+
+		Log.debug(`There are ${Object.entries(data).length} calendar entries.`);
+
+		const now = moment();
+		const pastLocalMoment = config.includePastEvents ? now.clone().startOf("day").subtract(config.maximumNumberOfDays, "days") : now;
+		const futureLocalMoment
+			= now
+				.clone()
+				.startOf("day")
+				.add(config.maximumNumberOfDays, "days")
+				// Subtract 1 second so that events that start on the middle of the night will not repeat.
+				.subtract(1, "seconds");
+
+		Object.entries(data).forEach(([key, event]) => {
+			if (event.type !== "VEVENT") {
+				return;
+			}
+
+			const title = CalendarFetcherUtils.getTitleFromEvent(event);
+			Log.debug(`title: ${title}`);
+
+			// Return quickly if event should be excluded.
+			const { excluded, until: eventFilterUntil } = CalendarFetcherUtils.shouldEventBeExcluded(config, title);
+			if (excluded) {
+				return;
+			}
+
+			Log.debug(`Event: ${title} | start: ${event.start} | end: ${event.end} | recurring: ${!!event.rrule}`);
+
+			const location = CalendarFetcherUtils.unwrapParameterValue(event.location) || false;
+			const geo = event.geo || false;
+			const description = CalendarFetcherUtils.unwrapParameterValue(event.description) || false;
+
+			let instances;
+			try {
+				instances = CalendarFetcherUtils.expandRecurringEvent(event, pastLocalMoment, futureLocalMoment);
+			} catch (error) {
+				Log.error(`Could not expand event "${title}": ${error.message}`);
+				return;
+			}
+
+			for (const instance of instances) {
+				const { event: instanceEvent, startMoment, endMoment, isRecurring, isFullDay } = instance;
+
+				// Filter logic
+				if (endMoment.isBefore(pastLocalMoment) || startMoment.isAfter(futureLocalMoment)) {
+					continue;
+				}
+
+				if (CalendarFetcherUtils.timeFilterApplies(now, endMoment, eventFilterUntil)) {
+					continue;
+				}
+
+				const instanceTitle = CalendarFetcherUtils.getTitleFromEvent(instanceEvent);
+
+				Log.debug(`saving event: ${instanceTitle}, start: ${startMoment.toDate()}, end: ${endMoment.toDate()}`);
+				newEvents.push({
+					title: instanceTitle,
+					startDate: startMoment.format("x"),
+					endDate: endMoment.format("x"),
+					fullDayEvent: isFullDay,
+					recurringEvent: isRecurring,
+					class: event.class,
+					firstYear: event.start.getFullYear(),
+					location: CalendarFetcherUtils.unwrapParameterValue(instanceEvent.location) || location,
+					geo: instanceEvent.geo || geo,
+					description: CalendarFetcherUtils.unwrapParameterValue(instanceEvent.description) || description
+				});
+			}
+		});
+
+		newEvents.sort(function (a, b) {
+			return a.startDate - b.startDate;
+		});
+
+		return newEvents;
+	},
+
+	/**
+	 * Gets the title from the event.
+	 * @param {object} event The event object to check.
+	 * @returns {string} The title of the event, or "Event" if no title is found.
+	 */
+	getTitleFromEvent (event) {
+		return CalendarFetcherUtils.unwrapParameterValue(event.summary || event.description) || "Event";
+	},
+
+	/**
+	 * Extracts the string value from a node-ical ParameterValue object ({val, params})
+	 * or returns the value as-is if it is already a plain string.
+	 * This handles ICS properties with parameters, e.g. DESCRIPTION;LANGUAGE=de:Text.
+	 * @param {string|object} value The raw value from node-ical
+	 * @returns {string|object} The unwrapped string value, or the original value if not a ParameterValue
+	 */
+	unwrapParameterValue (value) {
+		if (value && typeof value === "object" && typeof value.val !== "undefined") {
+			return value.val;
+		}
+		return value;
+	},
+
+	/**
+	 * Determines if the user defined time filter should apply
+	 * @param {moment.Moment} now Date object using previously created object for consistency
+	 * @param {moment.Moment} endDate Moment object representing the event end date
+	 * @param {string} filter The time to subtract from the end date to determine if an event should be shown
+	 * @returns {boolean} True if the event should be filtered out, false otherwise
+	 */
+	timeFilterApplies (now, endDate, filter) {
+		if (filter) {
+			const until = filter.split(" "),
+				value = parseInt(until[0]),
+				increment = until[1].slice(-1) === "s" ? until[1] : `${until[1]}s`, // Massage the data for moment js
+				filterUntil = moment(endDate.format()).subtract(value, increment);
+
+			return now.isBefore(filterUntil);
+		}
+
+		return false;
+	},
+
+	/**
+	 * Determines if the user defined title filter should apply
+	 * @param {string} title the title of the event
+	 * @param {string} filter the string to look for, can be a regex also
+	 * @param {boolean} useRegex true if a regex should be used, otherwise it just looks for the filter as a string
+	 * @param {string} regexFlags flags that should be applied to the regex
+	 * @returns {boolean} True if the title should be filtered out, false otherwise
+	 */
+	titleFilterApplies (title, filter, useRegex, regexFlags) {
+		if (useRegex) {
+			let regexFilter = filter;
+			// Assume if leading slash, there is also trailing slash
+			if (filter[0] === "/") {
+				// Strip leading and trailing slashes
+				regexFilter = filter.slice(1, -1);
+			}
+			return new RegExp(regexFilter, regexFlags).test(title);
+		} else {
+			return title.includes(filter);
+		}
+	},
+
+	/**
+	 * Expands a recurring event into individual event instances using node-ical.
+	 * Handles RRULE expansion, EXDATE filtering, RECURRENCE-ID overrides, and ongoing events.
+	 * @param {object} event The recurring event object
+	 * @param {moment.Moment} pastLocalMoment The past date limit
+	 * @param {moment.Moment} futureLocalMoment The future date limit
+	 * @returns {object[]} Array of event instances with startMoment/endMoment in the local timezone
+	 */
+	expandRecurringEvent (event, pastLocalMoment, futureLocalMoment) {
+		const localTimezone = CalendarFetcherUtils.getLocalTimezone();
+
+		return ical
+			.expandRecurringEvent(event, {
+				from: pastLocalMoment.toDate(),
+				to: futureLocalMoment.toDate(),
+				includeOverrides: true,
+				excludeExdates: true,
+				expandOngoing: true
+			})
+			.map((inst) => {
+				let startMoment, endMoment;
+				if (inst.isFullDay) {
+					startMoment = moment.tz([inst.start.getFullYear(), inst.start.getMonth(), inst.start.getDate()], localTimezone);
+					endMoment = moment.tz([inst.end.getFullYear(), inst.end.getMonth(), inst.end.getDate()], localTimezone);
+				} else {
+					startMoment = moment(inst.start).tz(localTimezone);
+					endMoment = moment(inst.end).tz(localTimezone);
+				}
+				// Events without DTEND (e.g. reminders) get start === end from node-ical;
+				// extend to end-of-day so they remain visible on the calendar.
+				if (startMoment.valueOf() === endMoment.valueOf()) endMoment = endMoment.endOf("day");
+				return { event: inst.event, startMoment, endMoment, isRecurring: inst.isRecurring, isFullDay: inst.isFullDay };
+			});
+	},
+
+	/**
+	 * Checks if an event title matches a specific filter configuration.
+	 * @param {string} title The event title to check
+	 * @param {string|object} filterConfig The filter configuration (string or object)
+	 * @returns {object|null} Object with {until: string|null} if matched, null otherwise
+	 */
+	checkEventAgainstFilter (title, filterConfig) {
+		let filter = filterConfig;
+		let testTitle = title.toLowerCase();
+		let until = null;
+		let useRegex = false;
+		let regexFlags = "g";
+
+		if (filter instanceof Object) {
+			if (typeof filter.until !== "undefined") {
+				until = filter.until;
+			}
+
+			if (typeof filter.regex !== "undefined") {
+				useRegex = filter.regex;
+			}
+
+			if (filter.caseSensitive) {
+				filter = filter.filterBy;
+				testTitle = title;
+			} else if (useRegex) {
+				filter = filter.filterBy;
+				testTitle = title;
+				regexFlags += "i";
+			} else {
+				filter = filter.filterBy.toLowerCase();
+			}
+		} else {
+			filter = filter.toLowerCase();
+		}
+
+		if (CalendarFetcherUtils.titleFilterApplies(testTitle, filter, useRegex, regexFlags)) {
+			return { until };
+		}
+
+		return null;
+	}
+};
+
+if (typeof module !== "undefined") {
+	module.exports = CalendarFetcherUtils;
+}

defaultmodules/calendar/debug.js

@@ -4,7 +4,7 @@
  * of starting the MagicMirror² core. Adjust the values below to your desire.
  */
 // Load internal alias resolver
-require("../../../js/alias-resolver");
+require("../../js/alias-resolver");
 const Log = require("logger");
 
 const CalendarFetcher = require("./calendarfetcher");

defaultmodules/calendar/node_helper.js

@@ -61,12 +61,11 @@ module.exports = NodeHelper.create({
 				this.broadcastEvents(fetcher, identifier);
 			});
 
-			fetcher.onError((fetcher, error) => {
-				Log.error("Calendar Error. Could not fetch calendar: ", fetcher.url, error);
-				let error_type = NodeHelper.checkFetchError(error);
+			fetcher.onError((fetcher, errorInfo) => {
+				Log.error("Calendar Error. Could not fetch calendar: ", fetcher.url, errorInfo.message || errorInfo);
 				this.sendSocketNotification("CALENDAR_ERROR", {
 					id: identifier,
-					error_type
+					error_type: errorInfo.translationKey
 				});
 			});
 

defaultmodules/newsfeed/newsfeed.css

@@ -0,0 +1,36 @@
+.newsfeed-fullarticle-container {
+  position: fixed;
+  width: 100vw;
+  height: 100vh;
+  top: 0;
+  left: 0;
+  overflow-y: auto;
+  scrollbar-width: none;
+  z-index: 1000;
+  background: black;
+}
+
+.newsfeed-fullarticle-container::-webkit-scrollbar {
+  display: none;
+}
+
+iframe.newsfeed-fullarticle {
+  display: block;
+  width: 100%;
+  height: 5000px;
+  border: none;
+}
+
+.region.bottom.bar.newsfeed-fullarticle {
+  bottom: inherit;
+  top: -90px;
+}
+
+.newsfeed-list {
+  list-style: none;
+}
+
+.newsfeed-list li {
+  text-align: justify;
+  margin-bottom: 0.5em;
+}

defaultmodules/newsfeed/newsfeed.js

@@ -74,6 +74,10 @@ Module.register("newsfeed", {
 		this.error = null;
 		this.activeItem = 0;
 		this.scrollPosition = 0;
+		this.articleIframe = null;
+		this.articleContainer = null;
+		this.articleFrameCheckPending = false;
+		this.articleUnavailable = false;
 
 		this.registerFeeds();
 
@@ -97,15 +101,60 @@ Module.register("newsfeed", {
 		} else if (notification === "NEWSFEED_ERROR") {
 			this.error = this.translate(payload.error_type);
 			this.scheduleUpdateInterval();
+		} else if (notification === "ARTICLE_URL_STATUS") {
+			if (this.config.showFullArticle) {
+				this.articleFrameCheckPending = false;
+				this.articleUnavailable = !payload.canFrame;
+				if (!this.articleUnavailable) {
+					// Article can be framed — now shift the bottom bar to allow scrolling
+					document.getElementsByClassName("region bottom bar")[0].classList.add("newsfeed-fullarticle");
+				}
+				this.updateDom(100);
+				if (this.articleUnavailable) {
+					// Briefly show the unavailable message, then return to normal newsfeed view
+					setTimeout(() => {
+						this.resetDescrOrFullArticleAndTimer();
+						this.updateDom(500);
+					}, 3000);
+				}
+			}
 		}
 	},
 
+	//Override getDom to handle the full article case with error handling
+	getDom () {
+		if (this.config.showFullArticle) {
+			this.activeItemHash = this.newsItems[this.activeItem]?.hash;
+			const wrapper = document.createElement("div");
+			if (this.articleFrameCheckPending) {
+				// Still waiting for the server-side framing check
+				wrapper.innerHTML = `<div class="small dimmed">${this.translate("LOADING")}</div>`;
+			} else if (this.articleUnavailable) {
+				wrapper.innerHTML = `<div class="small dimmed">${this.translate("NEWSFEED_ARTICLE_UNAVAILABLE")}</div>`;
+			} else {
+				const container = document.createElement("div");
+				container.className = "newsfeed-fullarticle-container";
+				container.scrollTop = this.scrollPosition;
+				const iframe = document.createElement("iframe");
+				iframe.className = "newsfeed-fullarticle";
+				// Always use the direct article URL — the CORS proxy is for server-side
+				// RSS feed fetching, not for browser iframes.
+				const item = this.newsItems[this.activeItem];
+				iframe.src = item ? (typeof item.url === "string" ? item.url : item.url.href) : "";
+				this.articleIframe = iframe;
+				this.articleContainer = container;
+				container.appendChild(iframe);
+				wrapper.appendChild(container);
+			}
+			return Promise.resolve(wrapper);
+		}
+		return this._super();
+	},
+
 	//Override fetching of template name
 	getTemplate () {
 		if (this.config.feedUrl) {
 			return "oldconfig.njk";
-		} else if (this.config.showFullArticle) {
-			return "fullarticle.njk";
 		}
 		return "newsfeed.njk";
 	},
@@ -116,13 +165,6 @@ Module.register("newsfeed", {
 			this.activeItem = 0;
 		}
 		this.activeItemCount = this.newsItems.length;
-		// this.config.showFullArticle is a run-time configuration, triggered by optional notifications
-		if (this.config.showFullArticle) {
-			this.activeItemHash = this.newsItems[this.activeItem]?.hash;
-			return {
-				url: this.getActiveItemURL()
-			};
-		}
 		if (this.error) {
 			this.activeItemHash = undefined;
 			return {
@@ -358,6 +400,10 @@ Module.register("newsfeed", {
 		this.isShowingDescription = this.config.showDescription;
 		this.config.showFullArticle = false;
 		this.scrollPosition = 0;
+		this.articleIframe = null;
+		this.articleContainer = null;
+		this.articleFrameCheckPending = false;
+		this.articleUnavailable = false;
 		// reset bottom bar alignment
 		document.getElementsByClassName("region bottom bar")[0].classList.remove("newsfeed-fullarticle");
 		if (!this.timer) {
@@ -386,23 +432,26 @@ Module.register("newsfeed", {
 			Log.debug(`[newsfeed] going from article #${before} to #${this.activeItem} (of ${this.newsItems.length})`);
 			this.updateDom(100);
 		}
-		// if "more details" is received the first time: show article summary, on second time show full article
 		else if (notification === "ARTICLE_MORE_DETAILS") {
-			// full article is already showing, so scrolling down
 			if (this.config.showFullArticle === true) {
+				// iframe already showing — scroll down
 				this.scrollPosition += this.config.scrollLength;
-				window.scrollTo(0, this.scrollPosition);
-				Log.debug("[newsfeed] scrolling down");
-				Log.debug(`[newsfeed] ARTICLE_MORE_DETAILS, scroll position: ${this.config.scrollLength}`);
-			} else {
+				if (this.articleContainer) this.articleContainer.scrollTop = this.scrollPosition;
+				Log.debug(`[newsfeed] scrolling down, offset: ${this.scrollPosition}`);
+			} else if (this.isShowingDescription) {
+				// description visible — step up to full article
 				this.showFullArticle();
+			} else {
+				// only title visible — show description first
+				this.isShowingDescription = true;
+				Log.debug("[newsfeed] showing article description");
+				this.updateDom(100);
 			}
 		} else if (notification === "ARTICLE_SCROLL_UP") {
 			if (this.config.showFullArticle === true) {
-				this.scrollPosition -= this.config.scrollLength;
-				window.scrollTo(0, this.scrollPosition);
-				Log.debug("[newsfeed] scrolling up");
-				Log.debug(`[newsfeed] ARTICLE_SCROLL_UP, scroll position: ${this.config.scrollLength}`);
+				this.scrollPosition = Math.max(0, this.scrollPosition - this.config.scrollLength);
+				if (this.articleContainer) this.articleContainer.scrollTop = this.scrollPosition;
+				Log.debug(`[newsfeed] scrolling up, offset: ${this.scrollPosition}`);
 			}
 		} else if (notification === "ARTICLE_LESS_DETAILS") {
 			this.resetDescrOrFullArticleAndTimer();
@@ -416,26 +465,37 @@ Module.register("newsfeed", {
 				this.showFullArticle();
 			}
 		} else if (notification === "ARTICLE_INFO_REQUEST") {
-			this.sendNotification("ARTICLE_INFO_RESPONSE", {
-				title: this.newsItems[this.activeItem].title,
-				source: this.newsItems[this.activeItem].sourceTitle,
-				date: this.newsItems[this.activeItem].pubdate,
-				desc: this.newsItems[this.activeItem].description,
-				url: this.getActiveItemURL()
-			});
+			const infoItem = this.newsItems[this.activeItem];
+			if (infoItem) {
+				this.sendNotification("ARTICLE_INFO_RESPONSE", {
+					title: infoItem.title,
+					source: infoItem.sourceTitle,
+					date: infoItem.pubdate,
+					desc: infoItem.description,
+					url: typeof infoItem.url === "string" ? infoItem.url : infoItem.url.href
+				});
+			}
 		}
 	},
 
 	showFullArticle () {
-		this.isShowingDescription = !this.isShowingDescription;
-		this.config.showFullArticle = !this.isShowingDescription;
-		// make bottom bar align to top to allow scrolling
-		if (this.config.showFullArticle === true) {
-			document.getElementsByClassName("region bottom bar")[0].classList.add("newsfeed-fullarticle");
+		const item = this.newsItems[this.activeItem];
+		const hasUrl = item && item.url && (typeof item.url === "string" ? item.url : item.url.href);
+		if (!hasUrl) {
+			Log.debug("[newsfeed] no article URL available, skipping full article view");
+			return;
 		}
+		this.isShowingDescription = false;
+		this.config.showFullArticle = true;
+		// Check server-side whether the article URL allows framing.
+		// The bottom bar CSS class is only added once we know the iframe will be shown.
+		this.articleFrameCheckPending = true;
+		this.articleUnavailable = false;
+		const rawUrl = typeof item.url === "string" ? item.url : item.url.href;
+		this.sendSocketNotification("CHECK_ARTICLE_URL", { url: rawUrl });
 		clearInterval(this.timer);
 		this.timer = null;
-		Log.debug(`[newsfeed] showing ${this.isShowingDescription ? "article description" : "full article"}`);
+		Log.debug("[newsfeed] showing full article");
 		this.updateDom(100);
 	}
 });

defaultmodules/newsfeed/newsfeedfetcher.js

@@ -0,0 +1,167 @@
+const crypto = require("node:crypto");
+const stream = require("node:stream");
+const FeedMe = require("feedme");
+const iconv = require("iconv-lite");
+const { htmlToText } = require("html-to-text");
+const Log = require("logger");
+const HTTPFetcher = require("#http_fetcher");
+
+/**
+ * NewsfeedFetcher - Fetches and parses RSS/Atom feed data
+ * Uses HTTPFetcher for HTTP handling with intelligent error handling
+ * @class
+ */
+class NewsfeedFetcher {
+
+	/**
+	 * Creates a new NewsfeedFetcher instance
+	 * @param {string} url - The URL of the news feed to fetch
+	 * @param {number} reloadInterval - Time in ms between fetches
+	 * @param {string} encoding - Encoding of the feed (e.g., 'UTF-8')
+	 * @param {boolean} logFeedWarnings - If true log warnings when there is an error parsing a news article
+	 * @param {boolean} useCorsProxy - If true cors proxy is used for article url's
+	 */
+	constructor (url, reloadInterval, encoding, logFeedWarnings, useCorsProxy) {
+		this.url = url;
+		this.encoding = encoding;
+		this.logFeedWarnings = logFeedWarnings;
+		this.useCorsProxy = useCorsProxy;
+		this.items = [];
+		this.fetchFailedCallback = () => {};
+		this.itemsReceivedCallback = () => {};
+
+		// Use HTTPFetcher for HTTP handling (Composition)
+		this.httpFetcher = new HTTPFetcher(url, {
+			reloadInterval: Math.max(reloadInterval, 1000),
+			headers: {
+				"Cache-Control": "max-age=0, no-cache, no-store, must-revalidate",
+				Pragma: "no-cache"
+			}
+		});
+
+		// Wire up HTTPFetcher events
+		this.httpFetcher.on("response", (response) => this.#handleResponse(response));
+		this.httpFetcher.on("error", (errorInfo) => this.fetchFailedCallback(this, errorInfo));
+	}
+
+	/**
+	 * Creates a parse error info object
+	 * @param {string} message - Error message
+	 * @param {Error} error - Original error
+	 * @returns {object} Error info object
+	 */
+	#createParseError (message, error) {
+		return {
+			message,
+			status: null,
+			errorType: "PARSE_ERROR",
+			translationKey: "MODULE_ERROR_UNSPECIFIED",
+			retryAfter: this.httpFetcher.reloadInterval,
+			retryCount: 0,
+			url: this.url,
+			originalError: error
+		};
+	}
+
+	/**
+	 * Handles successful HTTP response
+	 * @param {Response} response - The fetch Response object
+	 */
+	#handleResponse (response) {
+		this.items = [];
+		const parser = new FeedMe();
+
+		parser.on("item", (item) => {
+			const title = item.title;
+			let description = item.description || item.summary || item.content || "";
+			const pubdate = item.pubdate || item.published || item.updated || item["dc:date"] || item["a10:updated"];
+			const url = item.url || item.link || "";
+
+			if (title && pubdate) {
+				// Convert HTML entities, codes and tag
+				description = htmlToText(description, {
+					wordwrap: false,
+					selectors: [
+						{ selector: "a", options: { ignoreHref: true, noAnchorUrl: true } },
+						{ selector: "br", format: "inlineSurround", options: { prefix: " " } },
+						{ selector: "img", format: "skip" }
+					]
+				});
+
+				this.items.push({
+					title,
+					description,
+					pubdate,
+					url,
+					useCorsProxy: this.useCorsProxy,
+					hash: crypto.createHash("sha256").update(`${pubdate} :: ${title} :: ${url}`).digest("hex")
+				});
+			} else if (this.logFeedWarnings) {
+				Log.warn("Can't parse feed item:", item);
+				Log.warn(`Title: ${title}`);
+				Log.warn(`Description: ${description}`);
+				Log.warn(`Pubdate: ${pubdate}`);
+			}
+		});
+
+		parser.on("end", () => this.broadcastItems());
+
+		parser.on("error", (error) => {
+			Log.error(`${this.url} - Feed parsing failed: ${error.message}`);
+			this.fetchFailedCallback(this, this.#createParseError(`Feed parsing failed: ${error.message}`, error));
+		});
+
+		parser.on("ttl", (minutes) => {
+			const ttlms = Math.min(minutes * 60 * 1000, 86400000);
+			if (ttlms > this.httpFetcher.reloadInterval) {
+				this.httpFetcher.reloadInterval = ttlms;
+				Log.info(`reloadInterval set to ttl=${ttlms} for url ${this.url}`);
+			}
+		});
+
+		try {
+			const nodeStream = response.body instanceof stream.Readable
+				? response.body
+				: stream.Readable.fromWeb(response.body);
+			nodeStream.pipe(iconv.decodeStream(this.encoding)).pipe(parser);
+		} catch (error) {
+			Log.error(`${this.url} - Stream processing failed: ${error.message}`);
+			this.fetchFailedCallback(this, this.#createParseError(`Stream processing failed: ${error.message}`, error));
+		}
+	}
+
+	/**
+	 * Update the reload interval, but only if we need to increase the speed.
+	 * @param {number} interval - Interval for the update in milliseconds.
+	 */
+	setReloadInterval (interval) {
+		if (interval > 1000 && interval < this.httpFetcher.reloadInterval) {
+			this.httpFetcher.reloadInterval = interval;
+		}
+	}
+
+	startFetch () {
+		this.httpFetcher.startPeriodicFetch();
+	}
+
+	broadcastItems () {
+		if (this.items.length <= 0) {
+			Log.info("No items to broadcast yet.");
+			return;
+		}
+		Log.info(`Broadcasting ${this.items.length} items.`);
+		this.itemsReceivedCallback(this);
+	}
+
+	/** @param {function(NewsfeedFetcher): void} callback - Called when items are received */
+	onReceive (callback) {
+		this.itemsReceivedCallback = callback;
+	}
+
+	/** @param {function(NewsfeedFetcher, object): void} callback - Called on fetch error */
+	onError (callback) {
+		this.fetchFailedCallback = callback;
+	}
+}
+
+module.exports = NewsfeedFetcher;

defaultmodules/newsfeed/node_helper.js

@@ -13,6 +13,28 @@ module.exports = NodeHelper.create({
 	socketNotificationReceived (notification, payload) {
 		if (notification === "ADD_FEED") {
 			this.createFetcher(payload.feed, payload.config);
+		} else if (notification === "CHECK_ARTICLE_URL") {
+			this.checkArticleUrl(payload.url);
+		}
+	},
+
+	/**
+	 * Checks whether a URL can be displayed in an iframe by inspecting
+	 * X-Frame-Options and Content-Security-Policy headers server-side.
+	 * @param {string} url The article URL to check.
+	 */
+	async checkArticleUrl (url) {
+		try {
+			const response = await fetch(url, { method: "HEAD" });
+			const xfo = response.headers.get("x-frame-options");
+			const csp = response.headers.get("content-security-policy");
+			// sameorigin also blocks since the article is on a different origin than MM
+			const blockedByXFO = xfo && ["deny", "sameorigin"].includes(xfo.toLowerCase().trim());
+			const blockedByCSP = csp && (/frame-ancestors\s+['"]?none['"]?/).test(csp);
+			this.sendSocketNotification("ARTICLE_URL_STATUS", { url, canFrame: !blockedByXFO && !blockedByCSP });
+		} catch {
+			// Network error or HEAD not supported — let the browser try the iframe anyway
+			this.sendSocketNotification("ARTICLE_URL_STATUS", { url, canFrame: true });
 		}
 	},
 
@@ -26,8 +48,7 @@ module.exports = NodeHelper.create({
 		const url = feed.url || "";
 		const encoding = feed.encoding || "UTF-8";
 		const reloadInterval = feed.reloadInterval || config.reloadInterval || 5 * 60 * 1000;
-		let useCorsProxy = feed.useCorsProxy;
-		if (useCorsProxy === undefined) useCorsProxy = true;
+		const useCorsProxy = feed.useCorsProxy ?? true;
 
 		try {
 			new URL(url);
@@ -46,11 +67,10 @@ module.exports = NodeHelper.create({
 				this.broadcastFeeds();
 			});
 
-			fetcher.onError((fetcher, error) => {
-				Log.error("Error: Could not fetch newsfeed: ", url, error);
-				let error_type = NodeHelper.checkFetchError(error);
+			fetcher.onError((fetcher, errorInfo) => {
+				Log.error("Error: Could not fetch newsfeed: ", fetcher.url, errorInfo.message || errorInfo);
 				this.sendSocketNotification("NEWSFEED_ERROR", {
-					error_type
+					error_type: errorInfo.translationKey
 				});
 			});
 
@@ -71,8 +91,8 @@ module.exports = NodeHelper.create({
 	 */
 	broadcastFeeds () {
 		const feeds = {};
-		for (let f in this.fetchers) {
-			feeds[f] = this.fetchers[f].items();
+		for (const url in this.fetchers) {
+			feeds[url] = this.fetchers[url].items;
 		}
 		this.sendSocketNotification("NEWS_ITEMS", feeds);
 	}

defaultmodules/updatenotification/node_helper.js

@@ -2,7 +2,7 @@ const fs = require("node:fs");
 const path = require("node:path");
 const NodeHelper = require("node_helper");
 
-const defaultModules = require(`${global.root_path}/modules/default/defaultmodules`);
+const defaultModules = require(`${global.root_path}/${global.defaultModulesDir}/defaultmodules`);
 const GitHelper = require("./git_helper");
 const UpdateHelper = require("./update_helper");
 

defaultmodules/utils.js

@@ -0,0 +1,31 @@
+/**
+ * Format the time according to the config
+ * @param {object} config The config of the module
+ * @param {object} time time to format
+ * @returns {string} The formatted time string
+ */
+const formatTime = (config, time) => {
+	let date = moment(time);
+
+	if (config.timezone) {
+		date = date.tz(config.timezone);
+	}
+
+	if (config.timeFormat !== 24) {
+		if (config.showPeriod) {
+			if (config.showPeriodUpper) {
+				return date.format("h:mm A");
+			} else {
+				return date.format("h:mm a");
+			}
+		} else {
+			return date.format("h:mm");
+		}
+	}
+
+	return date.format("HH:mm");
+};
+
+if (typeof module !== "undefined") module.exports = {
+	formatTime
+};

defaultmodules/weather/current.njk

@@ -25,7 +25,7 @@
       {% if config.showHumidity === "wind" %}
         {{ humidity() }}
       {% endif %}
-      {% if config.showSun %}
+      {% if config.showSun and current.nextSunAction() %}
         <span class="wi dimmed wi-{{ current.nextSunAction() }}"></span>
         <span>
           {% if current.nextSunAction() === "sunset" %}

defaultmodules/weather/node_helper.js

@@ -0,0 +1,103 @@
+const path = require("node:path");
+const NodeHelper = require("node_helper");
+const Log = require("logger");
+
+module.exports = NodeHelper.create({
+	providers: {},
+
+	start () {
+		Log.log(`Starting node helper for: ${this.name}`);
+	},
+
+	socketNotificationReceived (notification, payload) {
+		if (notification === "INIT_WEATHER") {
+			Log.log(`Received INIT_WEATHER for instance ${payload.instanceId}`);
+			this.initWeatherProvider(payload);
+		} else if (notification === "STOP_WEATHER") {
+			Log.log(`Received STOP_WEATHER for instance ${payload.instanceId}`);
+			this.stopWeatherProvider(payload.instanceId);
+		}
+		// FETCH_WEATHER is no longer needed - HTTPFetcher handles periodic fetching
+	},
+
+	/**
+	 * Initialize a weather provider
+	 * @param {object} config The configuration object
+	 */
+	async initWeatherProvider (config) {
+		const identifier = config.weatherProvider.toLowerCase();
+		const instanceId = config.instanceId;
+
+		Log.log(`Attempting to initialize provider ${identifier} for instance ${instanceId}`);
+
+		if (this.providers[instanceId]) {
+			Log.log(`Weather provider ${identifier} already initialized for instance ${instanceId}`);
+			return;
+		}
+
+		try {
+			// Dynamically load the provider module
+			const providerPath = path.join(__dirname, "providers", `${identifier}.js`);
+			Log.log(`Loading provider from: ${providerPath}`);
+			const ProviderClass = require(providerPath);
+
+			// Create provider instance
+			const provider = new ProviderClass(config);
+
+			// Set up callbacks before initializing
+			provider.setCallbacks(
+				(data) => {
+					// On data received
+					this.sendSocketNotification("WEATHER_DATA", {
+						instanceId,
+						type: config.type,
+						data
+					});
+				},
+				(errorInfo) => {
+					// On error
+					this.sendSocketNotification("WEATHER_ERROR", {
+						instanceId,
+						error: errorInfo.message || "Unknown error",
+						translationKey: errorInfo.translationKey
+					});
+				}
+			);
+
+			await provider.initialize();
+			this.providers[instanceId] = provider;
+
+			this.sendSocketNotification("WEATHER_INITIALIZED", {
+				instanceId,
+				locationName: provider.locationName
+			});
+
+			// Start periodic fetching
+			provider.start();
+
+			Log.log(`Weather provider ${identifier} initialized for instance ${instanceId}`);
+		} catch (error) {
+			Log.error(`Failed to initialize weather provider ${identifier}:`, error);
+			this.sendSocketNotification("WEATHER_ERROR", {
+				instanceId,
+				error: error.message
+			});
+		}
+	},
+
+	/**
+	 * Stop and cleanup a weather provider
+	 * @param {string} instanceId The instance identifier
+	 */
+	stopWeatherProvider (instanceId) {
+		const provider = this.providers[instanceId];
+
+		if (provider) {
+			Log.log(`Stopping weather provider for instance ${instanceId}`);
+			provider.stop();
+			delete this.providers[instanceId];
+		} else {
+			Log.warn(`No provider found for instance ${instanceId}`);
+		}
+	}
+});

defaultmodules/weather/provider-utils.js

@@ -0,0 +1,181 @@
+/**
+ * Shared utility functions for weather providers
+ */
+
+const SunCalc = require("suncalc");
+
+/**
+ * Convert OpenWeatherMap icon codes to internal weather types
+ * @param {string} weatherType - OpenWeatherMap icon code (e.g., "01d", "02n")
+ * @returns {string|null} Internal weather type
+ */
+function convertWeatherType (weatherType) {
+	const weatherTypes = {
+		"01d": "day-sunny",
+		"02d": "day-cloudy",
+		"03d": "cloudy",
+		"04d": "cloudy-windy",
+		"09d": "showers",
+		"10d": "rain",
+		"11d": "thunderstorm",
+		"13d": "snow",
+		"50d": "fog",
+		"01n": "night-clear",
+		"02n": "night-cloudy",
+		"03n": "night-cloudy",
+		"04n": "night-cloudy",
+		"09n": "night-showers",
+		"10n": "night-rain",
+		"11n": "night-thunderstorm",
+		"13n": "night-snow",
+		"50n": "night-alt-cloudy-windy"
+	};
+
+	return weatherTypes.hasOwnProperty(weatherType) ? weatherTypes[weatherType] : null;
+}
+
+/**
+ * Apply timezone offset to a date
+ * @param {Date} date - The date to apply offset to
+ * @param {number} offsetMinutes - Timezone offset in minutes
+ * @returns {Date} Date with applied offset
+ */
+function applyTimezoneOffset (date, offsetMinutes) {
+	const utcTime = date.getTime() + (date.getTimezoneOffset() * 60000);
+	return new Date(utcTime + (offsetMinutes * 60000));
+}
+
+/**
+ * Limit decimal places for coordinates (truncate, not round)
+ * @param {number} value - The coordinate value
+ * @param {number} decimals - Maximum number of decimal places
+ * @returns {number} Value with limited decimal places
+ */
+function limitDecimals (value, decimals) {
+	const str = value.toString();
+	if (str.includes(".")) {
+		const parts = str.split(".");
+		if (parts[1].length > decimals) {
+			return parseFloat(`${parts[0]}.${parts[1].substring(0, decimals)}`);
+		}
+	}
+	return value;
+}
+
+/**
+ * Get sunrise and sunset times for a given date and location
+ * @param {Date} date - The date to calculate for
+ * @param {number} lat - Latitude
+ * @param {number} lon - Longitude
+ * @returns {object} Object with sunrise and sunset Date objects
+ */
+function getSunTimes (date, lat, lon) {
+	const sunTimes = SunCalc.getTimes(date, lat, lon);
+	return {
+		sunrise: sunTimes.sunrise,
+		sunset: sunTimes.sunset
+	};
+}
+
+/**
+ * Check if a given time is during daylight hours
+ * @param {Date} date - The date/time to check
+ * @param {Date} sunrise - Sunrise time
+ * @param {Date} sunset - Sunset time
+ * @returns {boolean} True if during daylight hours
+ */
+function isDayTime (date, sunrise, sunset) {
+	if (!sunrise || !sunset) {
+		return true; // Default to day if times unavailable
+	}
+	return date >= sunrise && date < sunset;
+}
+
+/**
+ * Format timezone offset as string (e.g., "+01:00", "-05:30")
+ * @param {number} offsetMinutes - Timezone offset in minutes (use -new Date().getTimezoneOffset() for local)
+ * @returns {string} Formatted offset string
+ */
+function formatTimezoneOffset (offsetMinutes) {
+	const hours = Math.floor(Math.abs(offsetMinutes) / 60);
+	const minutes = Math.abs(offsetMinutes) % 60;
+	const sign = offsetMinutes >= 0 ? "+" : "-";
+	return `${sign}${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+}
+
+/**
+ * Get date string in YYYY-MM-DD format (local time)
+ * @param {Date} date - The date to format
+ * @returns {string} Date string in YYYY-MM-DD format
+ */
+function getDateString (date) {
+	const year = date.getFullYear();
+	const month = String(date.getMonth() + 1).padStart(2, "0");
+	const day = String(date.getDate()).padStart(2, "0");
+	return `${year}-${month}-${day}`;
+}
+
+/**
+ * Convert wind speed from km/h to m/s
+ * @param {number} kmh - Wind speed in km/h
+ * @returns {number} Wind speed in m/s
+ */
+function convertKmhToMs (kmh) {
+	return kmh / 3.6;
+}
+
+/**
+ * Convert cardinal wind direction string to degrees
+ * @param {string} direction - Cardinal direction (e.g., "N", "NNE", "SW")
+ * @returns {number|null} Direction in degrees (0-360) or null if unknown
+ */
+function cardinalToDegrees (direction) {
+	const directions = {
+		N: 0,
+		NNE: 22.5,
+		NE: 45,
+		ENE: 67.5,
+		E: 90,
+		ESE: 112.5,
+		SE: 135,
+		SSE: 157.5,
+		S: 180,
+		SSW: 202.5,
+		SW: 225,
+		WSW: 247.5,
+		W: 270,
+		WNW: 292.5,
+		NW: 315,
+		NNW: 337.5
+	};
+	return directions[direction] ?? null;
+}
+
+/**
+ * Validate and limit coordinate precision
+ * @param {object} config - Configuration object with lat/lon properties
+ * @param {number} maxDecimals - Maximum decimal places to preserve
+ * @throws {Error} If coordinates are missing or invalid
+ */
+function validateCoordinates (config, maxDecimals = 4) {
+	if (config.lat == null || config.lon == null
+	  || !Number.isFinite(config.lat) || !Number.isFinite(config.lon)) {
+		throw new Error("Latitude and longitude are required");
+	}
+
+	config.lat = limitDecimals(config.lat, maxDecimals);
+	config.lon = limitDecimals(config.lon, maxDecimals);
+}
+
+module.exports = {
+	convertWeatherType,
+	applyTimezoneOffset,
+	limitDecimals,
+	getSunTimes,
+	isDayTime,
+	formatTimezoneOffset,
+	getDateString,
+	convertKmhToMs,
+	cardinalToDegrees,
+	validateCoordinates
+};

defaultmodules/weather/providers/README.md

@@ -1,3 +1,3 @@
 # Weather Module Weather Provider Development Documentation
 
-For how to develop your own weather provider, please check the [MagicMirror² documentation](https://docs.magicmirror.builders/development/weather-provider.html).
+For how to develop your own weather provider, please check the [MagicMirror² documentation](https://docs.magicmirror.builders/module-development/weather-provider.html).

defaultmodules/weather/providers/envcanada.js

@@ -0,0 +1,450 @@
+const Log = require("logger");
+const { convertKmhToMs } = require("../provider-utils");
+const HTTPFetcher = require("#http_fetcher");
+
+/**
+ * Server-side weather provider for Environment Canada MSC Datamart
+ * Canada only, no API key required (anonymous access)
+ *
+ * Documentation:
+ * https://dd.weather.gc.ca/citypage_weather/schema/
+ * https://eccc-msc.github.io/open-data/msc-datamart/readme_en/
+ *
+ * Requires siteCode and provCode config parameters
+ * See https://dd.weather.gc.ca/citypage_weather/docs/site_list_en.csv
+ */
+class EnvCanadaProvider {
+	constructor (config) {
+		this.config = {
+			siteCode: "s0000000",
+			provCode: "ON",
+			type: "current",
+			updateInterval: 10 * 60 * 1000,
+			...config
+		};
+
+		this.fetcher = null;
+		this.onDataCallback = null;
+		this.onErrorCallback = null;
+		this.lastCityPageURL = null;
+		this.cacheCurrentTemp = null;
+		this.currentHour = null; // Track current hour for URL updates
+	}
+
+	initialize () {
+		this.#validateConfig();
+		this.#initializeFetcher();
+	}
+
+	setCallbacks (onData, onError) {
+		this.onDataCallback = onData;
+		this.onErrorCallback = onError;
+	}
+
+	start () {
+		if (this.fetcher) {
+			this.fetcher.startPeriodicFetch();
+		}
+	}
+
+	stop () {
+		if (this.fetcher) {
+			this.fetcher.clearTimer();
+		}
+	}
+
+	#validateConfig () {
+		if (!this.config.siteCode || !this.config.provCode) {
+			throw new Error("siteCode and provCode are required");
+		}
+	}
+
+	#initializeFetcher () {
+		this.currentHour = new Date().toISOString().substring(11, 13);
+		const indexURL = this.#getIndexUrl();
+
+		this.fetcher = new HTTPFetcher(indexURL, {
+			reloadInterval: this.config.updateInterval,
+			logContext: "weatherprovider.envcanada"
+		});
+
+		this.fetcher.on("response", async (response) => {
+			try {
+				// Check if hour changed - restart fetcher with new URL
+				const newHour = new Date().toISOString().substring(11, 13);
+				if (newHour !== this.currentHour) {
+					Log.info("[envcanada] Hour changed, reinitializing fetcher");
+					this.stop();
+					this.#initializeFetcher();
+					this.start();
+					return;
+				}
+
+				const html = await response.text();
+				const cityPageURL = this.#extractCityPageURL(html);
+
+				if (!cityPageURL) {
+					// This can happen during hour transitions when old responses arrive
+					Log.debug("[envcanada] Could not find city page URL (may be stale response from previous hour)");
+					return;
+				}
+
+				if (cityPageURL === this.lastCityPageURL) {
+					Log.debug("[envcanada] City page unchanged");
+					return;
+				}
+
+				this.lastCityPageURL = cityPageURL;
+				await this.#fetchCityPage(cityPageURL);
+
+			} catch (error) {
+				Log.error("[envcanada] Error:", error);
+				if (this.onErrorCallback) {
+					this.onErrorCallback({
+						message: error.message,
+						translationKey: "MODULE_ERROR_UNSPECIFIED"
+					});
+				}
+			}
+		});
+
+		this.fetcher.on("error", (errorInfo) => {
+			if (this.onErrorCallback) {
+				this.onErrorCallback(errorInfo);
+			}
+		});
+	}
+
+	async #fetchCityPage (url) {
+		try {
+			const response = await fetch(url);
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+
+			const xml = await response.text();
+			const weatherData = this.#parseWeatherData(xml);
+
+			if (this.onDataCallback) {
+				this.onDataCallback(weatherData);
+			}
+		} catch (error) {
+			Log.error("[envcanada] Fetch city page error:", error);
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: "Failed to fetch city data",
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+		}
+	}
+
+	#parseWeatherData (xml) {
+		switch (this.config.type) {
+			case "current":
+				return this.#generateCurrentWeather(xml);
+			case "forecast":
+			case "daily":
+				return this.#generateForecast(xml);
+			case "hourly":
+				return this.#generateHourly(xml);
+			default:
+				Log.error(`[envcanada] Unknown weather type: ${this.config.type}`);
+				return null;
+		}
+	}
+
+	#generateCurrentWeather (xml) {
+		const current = { date: new Date() };
+
+		// Try to get temperature from currentConditions first
+		const currentTempStr = this.#extract(xml, /<currentConditions>.*?<temperature[^>]*>(.*?)<\/temperature>/s);
+
+		if (currentTempStr && currentTempStr !== "") {
+			current.temperature = parseFloat(currentTempStr);
+			this.cacheCurrentTemp = current.temperature;
+		} else {
+			// Fallback: extract from first forecast period if currentConditions is empty
+			const firstForecast = xml.match(/<forecast>(.*?)<\/forecast>/s);
+			if (firstForecast) {
+				const forecastXml = firstForecast[1];
+				const temp = this.#extract(forecastXml, /<temperature[^>]*>(.*?)<\/temperature>/);
+				if (temp && temp !== "") {
+					current.temperature = parseFloat(temp);
+					this.cacheCurrentTemp = current.temperature;
+				} else if (this.cacheCurrentTemp !== null) {
+					current.temperature = this.cacheCurrentTemp;
+				} else {
+					current.temperature = null;
+				}
+			}
+		}
+
+		// Wind chill / humidex for feels like temperature
+		const windChill = this.#extract(xml, /<windChill[^>]*>(.*?)<\/windChill>/);
+		const humidex = this.#extract(xml, /<humidex[^>]*>(.*?)<\/humidex>/);
+		if (windChill) {
+			current.feelsLikeTemp = parseFloat(windChill);
+		} else if (humidex) {
+			current.feelsLikeTemp = parseFloat(humidex);
+		}
+
+		// Get wind and icon from currentConditions or first forecast
+		const firstForecast = xml.match(/<forecast>(.*?)<\/forecast>/s);
+		if (!firstForecast) {
+			Log.warn("[envcanada] No forecast data available");
+			return current;
+		}
+
+		const forecastXml = firstForecast[1];
+
+		// Wind speed - try currentConditions first, fallback to forecast
+		let windSpeed = this.#extract(xml, /<currentConditions>.*?<wind>.*?<speed[^>]*>(.*?)<\/speed>/s);
+		if (!windSpeed) {
+			windSpeed = this.#extract(forecastXml, /<speed[^>]*>(.*?)<\/speed>/);
+		}
+		if (windSpeed) {
+			current.windSpeed = (windSpeed === "calm") ? 0 : convertKmhToMs(parseFloat(windSpeed));
+		}
+
+		// Wind bearing - try currentConditions first, fallback to forecast
+		let windBearing = this.#extract(xml, /<currentConditions>.*?<wind>.*?<bearing[^>]*>(.*?)<\/bearing>/s);
+		if (!windBearing) {
+			windBearing = this.#extract(forecastXml, /<bearing[^>]*>(.*?)<\/bearing>/);
+		}
+		if (windBearing) current.windFromDirection = parseFloat(windBearing);
+
+		// Try icon from currentConditions first, fallback to forecast
+		let iconCode = this.#extract(xml, /<currentConditions>.*?<iconCode[^>]*>(.*?)<\/iconCode>/s);
+		if (!iconCode) {
+			iconCode = this.#extract(forecastXml, /<iconCode[^>]*>(.*?)<\/iconCode>/);
+		}
+		if (iconCode) current.weatherType = this.#convertWeatherType(iconCode);
+
+		// Humidity from currentConditions
+		const humidity = this.#extract(xml, /<currentConditions>.*?<relativeHumidity[^>]*>(.*?)<\/relativeHumidity>/s);
+		if (humidity) current.humidity = parseFloat(humidity);
+
+		// Precipitation probability from forecast
+		const pop = this.#extract(forecastXml, /<pop[^>]*>(.*?)<\/pop>/);
+		if (pop && pop !== "") {
+			current.precipitationProbability = parseFloat(pop);
+		}
+
+		// Sunrise/sunset (from riseSet, independent of currentConditions)
+		const sunriseTime = this.#extract(xml, /<dateTime[^>]*name="sunrise"[^>]*>.*?<timeStamp>(.*?)<\/timeStamp>/s);
+		const sunsetTime = this.#extract(xml, /<dateTime[^>]*name="sunset"[^>]*>.*?<timeStamp>(.*?)<\/timeStamp>/s);
+		if (sunriseTime) current.sunrise = this.#parseECTime(sunriseTime);
+		if (sunsetTime) current.sunset = this.#parseECTime(sunsetTime);
+
+		return current;
+	}
+
+	#generateForecast (xml) {
+		const days = [];
+		const forecasts = xml.match(/<forecast>(.*?)<\/forecast>/gs) || [];
+
+		if (forecasts.length === 0) return days;
+
+		// Get current temp
+		const currentTempStr = this.#extract(xml, /<currentConditions>.*?<temperature[^>]*>(.*?)<\/temperature>/s);
+		const currentTemp = currentTempStr ? parseFloat(currentTempStr) : null;
+
+		// Check if first forecast is Today or Tonight
+		const isToday = forecasts[0].includes("textForecastName=\"Today\"");
+
+		let nextDay = isToday ? 2 : 1;
+		const lastDay = isToday ? 12 : 11;
+
+		// Process first day
+		const firstDay = {
+			date: new Date(),
+			precipitationProbability: null
+		};
+		this.#extractForecastTemps(firstDay, forecasts, 0, isToday, currentTemp);
+		this.#extractForecastPrecip(firstDay, forecasts, 0);
+		const firstIcon = this.#extract(forecasts[0], /<iconCode[^>]*>(.*?)<\/iconCode>/);
+		if (firstIcon) firstDay.weatherType = this.#convertWeatherType(firstIcon);
+		days.push(firstDay);
+
+		// Process remaining days
+		let date = new Date();
+		for (let i = nextDay; i < lastDay && i < forecasts.length; i += 2) {
+			date = new Date(date);
+			date.setDate(date.getDate() + 1);
+
+			const day = {
+				date: new Date(date),
+				precipitationProbability: null
+			};
+			this.#extractForecastTemps(day, forecasts, i, true, currentTemp);
+			this.#extractForecastPrecip(day, forecasts, i);
+			const icon = this.#extract(forecasts[i], /<iconCode[^>]*>(.*?)<\/iconCode>/);
+			if (icon) day.weatherType = this.#convertWeatherType(icon);
+			days.push(day);
+		}
+
+		return days;
+	}
+
+	#extractForecastTemps (weather, forecasts, index, hasToday, currentTemp) {
+		let tempToday = null;
+		let tempTonight = null;
+
+		if (hasToday && forecasts[index]) {
+			const temp = this.#extract(forecasts[index], /<temperature[^>]*>(.*?)<\/temperature>/);
+			if (temp) tempToday = parseFloat(temp);
+		}
+
+		if (forecasts[index + 1]) {
+			const temp = this.#extract(forecasts[index + 1], /<temperature[^>]*>(.*?)<\/temperature>/);
+			if (temp) tempTonight = parseFloat(temp);
+		}
+
+		if (tempToday !== null && tempTonight !== null) {
+			weather.maxTemperature = Math.max(tempToday, tempTonight);
+			weather.minTemperature = Math.min(tempToday, tempTonight);
+		} else if (tempToday !== null) {
+			weather.maxTemperature = tempToday;
+			weather.minTemperature = currentTemp || tempToday;
+		} else if (tempTonight !== null) {
+			weather.maxTemperature = currentTemp || tempTonight;
+			weather.minTemperature = tempTonight;
+		}
+	}
+
+	#extractForecastPrecip (weather, forecasts, index) {
+		const precips = [];
+
+		if (forecasts[index]) {
+			const pop = this.#extract(forecasts[index], /<pop[^>]*>(.*?)<\/pop>/);
+			if (pop) precips.push(parseFloat(pop));
+		}
+
+		if (forecasts[index + 1]) {
+			const pop = this.#extract(forecasts[index + 1], /<pop[^>]*>(.*?)<\/pop>/);
+			if (pop) precips.push(parseFloat(pop));
+		}
+
+		if (precips.length > 0) {
+			weather.precipitationProbability = Math.max(...precips);
+		}
+	}
+
+	#generateHourly (xml) {
+		const hours = [];
+		const hourlyMatches = xml.matchAll(/<hourlyForecast[^>]*dateTimeUTC="([^"]*)"[^>]*>(.*?)<\/hourlyForecast>/gs);
+
+		for (const [, dateTimeUTC, hourXML] of hourlyMatches) {
+			const weather = {};
+
+			weather.date = this.#parseECTime(dateTimeUTC);
+
+			const temp = this.#extract(hourXML, /<temperature[^>]*>(.*?)<\/temperature>/);
+			if (temp) weather.temperature = parseFloat(temp);
+
+			const lop = this.#extract(hourXML, /<lop[^>]*>(.*?)<\/lop>/);
+			if (lop) weather.precipitationProbability = parseFloat(lop);
+
+			const icon = this.#extract(hourXML, /<iconCode[^>]*>(.*?)<\/iconCode>/);
+			if (icon) weather.weatherType = this.#convertWeatherType(icon);
+
+			hours.push(weather);
+			if (hours.length >= 24) break;
+		}
+
+		return hours;
+	}
+
+	#extract (text, pattern) {
+		const match = text.match(pattern);
+		return match ? match[1].trim() : null;
+	}
+
+	#getIndexUrl () {
+		const hour = new Date().toISOString().substring(11, 13);
+		return `https://dd.weather.gc.ca/today/citypage_weather/${this.config.provCode}/${hour}/`;
+	}
+
+	#extractCityPageURL (html) {
+		// New format: {timestamp}_MSC_CitypageWeather_{siteCode}_en.xml
+		const pattern = `[^"]*_MSC_CitypageWeather_${this.config.siteCode}_en\\.xml`;
+		const match = html.match(new RegExp(`href="(${pattern})"`));
+
+		if (match && match[1]) {
+			return this.#getIndexUrl() + match[1];
+		}
+
+		return null;
+	}
+
+	#parseECTime (timeStr) {
+		if (!timeStr || timeStr.length < 12) return new Date();
+
+		const y = parseInt(timeStr.substring(0, 4), 10);
+		const m = parseInt(timeStr.substring(4, 6), 10) - 1;
+		const d = parseInt(timeStr.substring(6, 8), 10);
+		const h = parseInt(timeStr.substring(8, 10), 10);
+		const min = parseInt(timeStr.substring(10, 12), 10);
+		const s = timeStr.length >= 14 ? parseInt(timeStr.substring(12, 14), 10) : 0;
+
+		// Create UTC date since input timestamps are in UTC
+		return new Date(Date.UTC(y, m, d, h, min, s));
+	}
+
+	#convertWeatherType (iconCode) {
+		const code = parseInt(iconCode, 10);
+		const map = {
+			0: "day-sunny",
+			1: "day-sunny",
+			2: "day-sunny-overcast",
+			3: "day-cloudy",
+			4: "day-cloudy",
+			5: "day-cloudy",
+			6: "day-sprinkle",
+			7: "day-showers",
+			8: "snow",
+			9: "day-thunderstorm",
+			10: "cloud",
+			11: "showers",
+			12: "rain",
+			13: "rain",
+			14: "sleet",
+			15: "sleet",
+			16: "snow",
+			17: "snow",
+			18: "snow",
+			19: "thunderstorm",
+			20: "cloudy",
+			21: "cloudy",
+			22: "day-cloudy",
+			23: "day-haze",
+			24: "fog",
+			25: "snow-wind",
+			26: "sleet",
+			27: "sleet",
+			28: "rain",
+			29: "na",
+			30: "night-clear",
+			31: "night-clear",
+			32: "night-partly-cloudy",
+			33: "night-alt-cloudy",
+			34: "night-alt-cloudy",
+			35: "night-partly-cloudy",
+			36: "night-alt-showers",
+			37: "night-rain-mix",
+			38: "night-alt-snow",
+			39: "night-thunderstorm",
+			40: "snow-wind",
+			41: "tornado",
+			42: "tornado",
+			43: "windy",
+			44: "smoke",
+			45: "sandstorm",
+			46: "thunderstorm",
+			47: "thunderstorm",
+			48: "tornado"
+		};
+		return map[code] || null;
+	}
+}
+
+module.exports = EnvCanadaProvider;

defaultmodules/weather/providers/openmeteo.js

@@ -0,0 +1,560 @@
+const Log = require("logger");
+const { getDateString } = require("../provider-utils");
+const HTTPFetcher = require("#http_fetcher");
+
+// https://www.bigdatacloud.com/docs/api/free-reverse-geocode-to-city-api
+const GEOCODE_BASE = "https://api.bigdatacloud.net/data/reverse-geocode-client";
+const OPEN_METEO_BASE = "https://api.open-meteo.com/v1";
+
+/**
+ * Server-side weather provider for Open-Meteo
+ * see https://open-meteo.com/
+ */
+class OpenMeteoProvider {
+	// https://open-meteo.com/en/docs
+	hourlyParams = [
+		"temperature_2m",
+		"relativehumidity_2m",
+		"dewpoint_2m",
+		"apparent_temperature",
+		"pressure_msl",
+		"surface_pressure",
+		"cloudcover",
+		"cloudcover_low",
+		"cloudcover_mid",
+		"cloudcover_high",
+		"windspeed_10m",
+		"windspeed_80m",
+		"windspeed_120m",
+		"windspeed_180m",
+		"winddirection_10m",
+		"winddirection_80m",
+		"winddirection_120m",
+		"winddirection_180m",
+		"windgusts_10m",
+		"shortwave_radiation",
+		"direct_radiation",
+		"direct_normal_irradiance",
+		"diffuse_radiation",
+		"vapor_pressure_deficit",
+		"cape",
+		"evapotranspiration",
+		"et0_fao_evapotranspiration",
+		"precipitation",
+		"snowfall",
+		"precipitation_probability",
+		"rain",
+		"showers",
+		"weathercode",
+		"snow_depth",
+		"freezinglevel_height",
+		"visibility",
+		"soil_temperature_0cm",
+		"soil_temperature_6cm",
+		"soil_temperature_18cm",
+		"soil_temperature_54cm",
+		"soil_moisture_0_1cm",
+		"soil_moisture_1_3cm",
+		"soil_moisture_3_9cm",
+		"soil_moisture_9_27cm",
+		"soil_moisture_27_81cm",
+		"uv_index",
+		"uv_index_clear_sky",
+		"is_day",
+		"terrestrial_radiation",
+		"terrestrial_radiation_instant",
+		"shortwave_radiation_instant",
+		"diffuse_radiation_instant",
+		"direct_radiation_instant",
+		"direct_normal_irradiance_instant"
+	];
+
+	dailyParams = [
+		"temperature_2m_max",
+		"temperature_2m_min",
+		"apparent_temperature_min",
+		"apparent_temperature_max",
+		"precipitation_sum",
+		"rain_sum",
+		"showers_sum",
+		"snowfall_sum",
+		"precipitation_hours",
+		"weathercode",
+		"sunrise",
+		"sunset",
+		"windspeed_10m_max",
+		"windgusts_10m_max",
+		"winddirection_10m_dominant",
+		"shortwave_radiation_sum",
+		"uv_index_max",
+		"et0_fao_evapotranspiration"
+	];
+
+	constructor (config) {
+		this.config = {
+			apiBase: OPEN_METEO_BASE,
+			lat: 0,
+			lon: 0,
+			pastDays: 0,
+			type: "current",
+			maxNumberOfDays: 5,
+			updateInterval: 10 * 60 * 1000,
+			...config
+		};
+
+		this.locationName = null;
+		this.fetcher = null;
+		this.onDataCallback = null;
+		this.onErrorCallback = null;
+	}
+
+	async initialize () {
+		await this.#fetchLocation();
+		this.#initializeFetcher();
+	}
+
+	/**
+	 * Set callbacks for data/error events
+	 * @param {(data: object) => void} onData - Called with weather data
+	 * @param {(error: object) => void} onError - Called with error info
+	 */
+	setCallbacks (onData, onError) {
+		this.onDataCallback = onData;
+		this.onErrorCallback = onError;
+	}
+
+	/**
+	 * Start periodic fetching
+	 */
+	start () {
+		if (this.fetcher) {
+			this.fetcher.startPeriodicFetch();
+		}
+	}
+
+	/**
+	 * Stop periodic fetching
+	 */
+	stop () {
+		if (this.fetcher) {
+			this.fetcher.clearTimer();
+		}
+	}
+
+	async #fetchLocation () {
+		const url = `${GEOCODE_BASE}?latitude=${this.config.lat}&longitude=${this.config.lon}&localityLanguage=${this.config.lang || "en"}`;
+
+		try {
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), 10000);
+
+			const response = await fetch(url, { signal: controller.signal });
+			clearTimeout(timeoutId);
+
+			if (!response.ok) {
+				throw new Error(`HTTP ${response.status}`);
+			}
+			const data = await response.json();
+			if (data && data.city) {
+				this.locationName = `${data.city}, ${data.principalSubdivisionCode}`;
+			}
+		} catch (error) {
+			Log.debug("[openmeteo] Could not load location data:", error.message);
+		}
+	}
+
+	#initializeFetcher () {
+		const url = this.#getUrl();
+
+		this.fetcher = new HTTPFetcher(url, {
+			reloadInterval: this.config.updateInterval,
+			headers: { "Cache-Control": "no-cache" },
+			logContext: "weatherprovider.openmeteo"
+		});
+
+		this.fetcher.on("response", async (response) => {
+			try {
+				const data = await response.json();
+				this.#handleResponse(data);
+			} catch (error) {
+				Log.error("[openmeteo] Failed to parse JSON:", error);
+				if (this.onErrorCallback) {
+					this.onErrorCallback({
+						message: "Failed to parse API response",
+						translationKey: "MODULE_ERROR_UNSPECIFIED"
+					});
+				}
+			}
+		});
+
+		this.fetcher.on("error", (errorInfo) => {
+			if (this.onErrorCallback) {
+				this.onErrorCallback(errorInfo);
+			}
+		});
+	}
+
+	#handleResponse (data) {
+		const parsedData = this.#parseWeatherApiResponse(data);
+
+		if (!parsedData) {
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: "Invalid API response",
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+			return;
+		}
+
+		try {
+			let weatherData;
+			switch (this.config.type) {
+				case "current":
+					weatherData = this.#generateWeatherDayFromCurrentWeather(parsedData);
+					break;
+				case "forecast":
+				case "daily":
+					weatherData = this.#generateWeatherObjectsFromForecast(parsedData);
+					break;
+				case "hourly":
+					weatherData = this.#generateWeatherObjectsFromHourly(parsedData);
+					break;
+				default:
+					Log.error(`[openmeteo] Unknown type: ${this.config.type}`);
+					throw new Error(`Unknown weather type: ${this.config.type}`);
+			}
+
+			if (weatherData && this.onDataCallback) {
+				this.onDataCallback(weatherData);
+			}
+		} catch (error) {
+			Log.error("[openmeteo] Error processing weather data:", error);
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: error.message,
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+		}
+	}
+
+	#getQueryParameters () {
+		let maxNumberOfDays = this.config.maxNumberOfDays;
+
+		if (this.config.maxNumberOfDays !== undefined && !isNaN(parseFloat(this.config.maxNumberOfDays))) {
+			const maxEntriesLimit = ["daily", "forecast"].includes(this.config.type) ? 7 : this.config.type === "hourly" ? 48 : 0;
+			const daysFactor = ["daily", "forecast"].includes(this.config.type) ? 1 : this.config.type === "hourly" ? 24 : 0;
+			const maxEntries = Math.max(1, Math.min(Math.round(parseFloat(this.config.maxNumberOfDays)) * daysFactor, maxEntriesLimit));
+			maxNumberOfDays = Math.ceil(maxEntries / Math.max(1, daysFactor));
+		}
+
+		const params = {
+			latitude: this.config.lat,
+			longitude: this.config.lon,
+			timeformat: "unixtime",
+			timezone: "auto",
+			past_days: this.config.pastDays ?? 0,
+			daily: this.dailyParams,
+			hourly: this.hourlyParams,
+			temperature_unit: "celsius",
+			windspeed_unit: "ms",
+			precipitation_unit: "mm"
+		};
+
+		const now = new Date();
+		const startDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+		const endDate = new Date(startDate);
+		endDate.setDate(endDate.getDate() + Math.max(0, Math.min(7, maxNumberOfDays)));
+
+		params.start_date = getDateString(startDate);
+
+		switch (this.config.type) {
+			case "hourly":
+			case "daily":
+			case "forecast":
+				params.end_date = getDateString(endDate);
+				break;
+			case "current":
+				params.current_weather = true;
+				params.end_date = params.start_date;
+				break;
+			default:
+				return "";
+		}
+
+		return Object.keys(params)
+			.filter((key) => params[key] !== undefined && params[key] !== null && params[key] !== "")
+			.map((key) => {
+				switch (key) {
+					case "hourly":
+					case "daily":
+						return `${encodeURIComponent(key)}=${params[key].join(",")}`;
+					default:
+						return `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`;
+				}
+			})
+			.join("&");
+	}
+
+	#getUrl () {
+		return `${this.config.apiBase}/forecast?${this.#getQueryParameters()}`;
+	}
+
+	#transposeDataMatrix (data) {
+		return data.time.map((_, index) => Object.keys(data).reduce((row, key) => {
+			const value = data[key][index];
+			return {
+				...row,
+				// Convert Unix timestamps to Date objects
+				// timezone: "auto" returns times already in location timezone
+				[key]: ["time", "sunrise", "sunset"].includes(key) ? new Date(value * 1000) : value
+			};
+		}, {}));
+	}
+
+	#parseWeatherApiResponse (data) {
+		const validByType = {
+			current: data.current_weather && data.current_weather.time,
+			hourly: data.hourly && data.hourly.time && Array.isArray(data.hourly.time) && data.hourly.time.length > 0,
+			daily: data.daily && data.daily.time && Array.isArray(data.daily.time) && data.daily.time.length > 0
+		};
+
+		const type = ["daily", "forecast"].includes(this.config.type) ? "daily" : this.config.type;
+
+		if (!validByType[type]) return null;
+
+		if (type === "current" && !validByType.daily && !validByType.hourly) {
+			return null;
+		}
+
+		for (const key of ["hourly", "daily"]) {
+			if (typeof data[key] === "object") {
+				data[key] = this.#transposeDataMatrix(data[key]);
+			}
+		}
+
+		if (data.current_weather) {
+			data.current_weather.time = new Date(data.current_weather.time * 1000);
+		}
+
+		return data;
+	}
+
+	#convertWeatherType (weathercode, isDayTime) {
+		const weatherConditions = {
+			0: "clear",
+			1: "mainly-clear",
+			2: "partly-cloudy",
+			3: "overcast",
+			45: "fog",
+			48: "depositing-rime-fog",
+			51: "drizzle-light-intensity",
+			53: "drizzle-moderate-intensity",
+			55: "drizzle-dense-intensity",
+			56: "freezing-drizzle-light-intensity",
+			57: "freezing-drizzle-dense-intensity",
+			61: "rain-slight-intensity",
+			63: "rain-moderate-intensity",
+			65: "rain-heavy-intensity",
+			66: "freezing-rain-light-intensity",
+			67: "freezing-rain-heavy-intensity",
+			71: "snow-fall-slight-intensity",
+			73: "snow-fall-moderate-intensity",
+			75: "snow-fall-heavy-intensity",
+			77: "snow-grains",
+			80: "rain-showers-slight",
+			81: "rain-showers-moderate",
+			82: "rain-showers-violent",
+			85: "snow-showers-slight",
+			86: "snow-showers-heavy",
+			95: "thunderstorm",
+			96: "thunderstorm-slight-hail",
+			99: "thunderstorm-heavy-hail"
+		};
+
+		if (!(weathercode in weatherConditions)) return null;
+
+		const mappings = {
+			clear: isDayTime ? "day-sunny" : "night-clear",
+			"mainly-clear": isDayTime ? "day-cloudy" : "night-alt-cloudy",
+			"partly-cloudy": isDayTime ? "day-cloudy" : "night-alt-cloudy",
+			overcast: isDayTime ? "day-sunny-overcast" : "night-alt-partly-cloudy",
+			fog: isDayTime ? "day-fog" : "night-fog",
+			"depositing-rime-fog": isDayTime ? "day-fog" : "night-fog",
+			"drizzle-light-intensity": isDayTime ? "day-sprinkle" : "night-sprinkle",
+			"rain-slight-intensity": isDayTime ? "day-sprinkle" : "night-sprinkle",
+			"rain-showers-slight": isDayTime ? "day-sprinkle" : "night-sprinkle",
+			"drizzle-moderate-intensity": isDayTime ? "day-showers" : "night-showers",
+			"rain-moderate-intensity": isDayTime ? "day-showers" : "night-showers",
+			"rain-showers-moderate": isDayTime ? "day-showers" : "night-showers",
+			"drizzle-dense-intensity": isDayTime ? "day-thunderstorm" : "night-thunderstorm",
+			"rain-heavy-intensity": isDayTime ? "day-thunderstorm" : "night-thunderstorm",
+			"rain-showers-violent": isDayTime ? "day-thunderstorm" : "night-thunderstorm",
+			"freezing-rain-light-intensity": isDayTime ? "day-rain-mix" : "night-rain-mix",
+			"freezing-drizzle-light-intensity": "snowflake-cold",
+			"freezing-drizzle-dense-intensity": "snowflake-cold",
+			"snow-grains": isDayTime ? "day-sleet" : "night-sleet",
+			"snow-fall-slight-intensity": isDayTime ? "day-snow-wind" : "night-snow-wind",
+			"snow-fall-moderate-intensity": isDayTime ? "day-snow-wind" : "night-snow-wind",
+			"snow-fall-heavy-intensity": isDayTime ? "day-snow-thunderstorm" : "night-snow-thunderstorm",
+			"freezing-rain-heavy-intensity": isDayTime ? "day-snow-thunderstorm" : "night-snow-thunderstorm",
+			"snow-showers-slight": isDayTime ? "day-rain-mix" : "night-rain-mix",
+			"snow-showers-heavy": isDayTime ? "day-rain-mix" : "night-rain-mix",
+			thunderstorm: isDayTime ? "day-thunderstorm" : "night-thunderstorm",
+			"thunderstorm-slight-hail": isDayTime ? "day-sleet" : "night-sleet",
+			"thunderstorm-heavy-hail": isDayTime ? "day-sleet-storm" : "night-sleet-storm"
+		};
+
+		return mappings[weatherConditions[`${weathercode}`]] || "na";
+	}
+
+	#isDayTime (date, sunrise, sunset) {
+		const time = date.getTime();
+		return time >= sunrise.getTime() && time < sunset.getTime();
+	}
+
+	#generateWeatherDayFromCurrentWeather (parsedData) {
+		// Basic current weather data
+		const current = {
+			date: parsedData.current_weather.time,
+			windSpeed: parsedData.current_weather.windspeed,
+			windFromDirection: parsedData.current_weather.winddirection,
+			temperature: parsedData.current_weather.temperature,
+			weatherType: this.#convertWeatherType(parsedData.current_weather.weathercode, true)
+		};
+
+		// Add hourly data if available
+		if (parsedData.hourly) {
+			let h;
+			const currentTime = parsedData.current_weather.time;
+
+			// Handle both data shapes: object with arrays or array of objects (after transpose)
+			if (Array.isArray(parsedData.hourly)) {
+				// Array of objects (after transpose)
+				const hourlyIndex = parsedData.hourly.findIndex((hour) => hour.time.getTime() === currentTime.getTime());
+				h = hourlyIndex !== -1 ? hourlyIndex : 0;
+
+				if (hourlyIndex === -1) {
+					Log.debug("[openmeteo] Could not find current time in hourly data, using index 0");
+				}
+
+				const hourData = parsedData.hourly[h];
+				if (hourData) {
+					current.humidity = hourData.relativehumidity_2m;
+					current.feelsLikeTemp = hourData.apparent_temperature;
+					current.rain = hourData.rain;
+					current.snow = hourData.snowfall ? hourData.snowfall * 10 : undefined;
+					current.precipitationAmount = hourData.precipitation;
+					current.precipitationProbability = hourData.precipitation_probability;
+					current.uvIndex = hourData.uv_index;
+				}
+			} else if (parsedData.hourly.time) {
+				// Object with arrays (before transpose - shouldn't happen in normal flow)
+				const hourlyIndex = parsedData.hourly.time.findIndex((time) => time === currentTime);
+				h = hourlyIndex !== -1 ? hourlyIndex : 0;
+
+				if (hourlyIndex === -1) {
+					Log.debug("[openmeteo] Could not find current time in hourly data, using index 0");
+				}
+
+				current.humidity = parsedData.hourly.relativehumidity_2m?.[h];
+				current.feelsLikeTemp = parsedData.hourly.apparent_temperature?.[h];
+				current.rain = parsedData.hourly.rain?.[h];
+				current.snow = parsedData.hourly.snowfall?.[h] ? parsedData.hourly.snowfall[h] * 10 : undefined;
+				current.precipitationAmount = parsedData.hourly.precipitation?.[h];
+				current.precipitationProbability = parsedData.hourly.precipitation_probability?.[h];
+				current.uvIndex = parsedData.hourly.uv_index?.[h];
+			}
+		}
+
+		// Add daily data if available (after transpose, daily is array of objects)
+		if (parsedData.daily && Array.isArray(parsedData.daily) && parsedData.daily[0]) {
+			const today = parsedData.daily[0];
+			if (today.sunrise) {
+				current.sunrise = today.sunrise;
+			}
+			if (today.sunset) {
+				current.sunset = today.sunset;
+				// Update weatherType with correct day/night status
+				if (current.sunrise && current.sunset) {
+					current.weatherType = this.#convertWeatherType(
+						parsedData.current_weather.weathercode,
+						this.#isDayTime(parsedData.current_weather.time, current.sunrise, current.sunset)
+					);
+				}
+			}
+			if (today.temperature_2m_min !== undefined) {
+				current.minTemperature = today.temperature_2m_min;
+			}
+			if (today.temperature_2m_max !== undefined) {
+				current.maxTemperature = today.temperature_2m_max;
+			}
+		}
+
+		return current;
+	}
+
+	#generateWeatherObjectsFromForecast (parsedData) {
+		return parsedData.daily.map((weather) => ({
+			date: weather.time,
+			windSpeed: weather.windspeed_10m_max,
+			windFromDirection: weather.winddirection_10m_dominant,
+			sunrise: weather.sunrise,
+			sunset: weather.sunset,
+			temperature: parseFloat((weather.temperature_2m_max + weather.temperature_2m_min) / 2),
+			minTemperature: parseFloat(weather.temperature_2m_min),
+			maxTemperature: parseFloat(weather.temperature_2m_max),
+			weatherType: this.#convertWeatherType(weather.weathercode, true),
+			rain: weather.rain_sum != null ? parseFloat(weather.rain_sum) : null,
+			snow: weather.snowfall_sum != null ? parseFloat(weather.snowfall_sum * 10) : null,
+			precipitationAmount: weather.precipitation_sum != null ? parseFloat(weather.precipitation_sum) : null,
+			precipitationProbability: weather.precipitation_hours != null ? parseFloat(weather.precipitation_hours * 100 / 24) : null,
+			uvIndex: weather.uv_index_max != null ? parseFloat(weather.uv_index_max) : null
+		}));
+	}
+
+	#generateWeatherObjectsFromHourly (parsedData) {
+		const hours = [];
+		const now = new Date();
+
+		parsedData.hourly.forEach((weather, i) => {
+			// Skip past entries
+			if (weather.time <= now) {
+				return;
+			}
+
+			// Calculate daily index with bounds check
+			const h = Math.ceil((i + 1) / 24) - 1;
+			const safeH = Math.max(0, Math.min(h, parsedData.daily.length - 1));
+			const dailyData = parsedData.daily[safeH];
+
+			const hourlyWeather = {
+				date: weather.time,
+				windSpeed: weather.windspeed_10m,
+				windFromDirection: weather.winddirection_10m,
+				sunrise: dailyData.sunrise,
+				sunset: dailyData.sunset,
+				temperature: parseFloat(weather.temperature_2m),
+				minTemperature: parseFloat(dailyData.temperature_2m_min),
+				maxTemperature: parseFloat(dailyData.temperature_2m_max),
+				weatherType: this.#convertWeatherType(
+					weather.weathercode,
+					this.#isDayTime(weather.time, dailyData.sunrise, dailyData.sunset)
+				),
+				humidity: weather.relativehumidity_2m != null ? parseFloat(weather.relativehumidity_2m) : null,
+				rain: weather.rain != null ? parseFloat(weather.rain) : null,
+				snow: weather.snowfall != null ? parseFloat(weather.snowfall * 10) : null,
+				precipitationAmount: weather.precipitation != null ? parseFloat(weather.precipitation) : null,
+				precipitationProbability: weather.precipitation_probability != null ? parseFloat(weather.precipitation_probability) : null,
+				uvIndex: weather.uv_index != null ? parseFloat(weather.uv_index) : null
+			};
+
+			hours.push(hourlyWeather);
+		});
+
+		return hours;
+	}
+}
+
+module.exports = OpenMeteoProvider;

defaultmodules/weather/providers/openweathermap.js

@@ -0,0 +1,276 @@
+const Log = require("logger");
+const weatherUtils = require("../provider-utils");
+const HTTPFetcher = require("#http_fetcher");
+
+/**
+ * Server-side weather provider for OpenWeatherMap
+ * see https://openweathermap.org/
+ */
+class OpenWeatherMapProvider {
+	constructor (config) {
+		this.config = {
+			apiVersion: "3.0",
+			apiBase: "https://api.openweathermap.org/data/",
+			weatherEndpoint: "/onecall",
+			locationID: false,
+			location: false,
+			lat: 0,
+			lon: 0,
+			apiKey: "",
+			type: "current",
+			updateInterval: 10 * 60 * 1000,
+			...config
+		};
+
+		this.fetcher = null;
+		this.onDataCallback = null;
+		this.onErrorCallback = null;
+		this.locationName = null;
+	}
+
+	initialize () {
+		// Validate callbacks exist
+		if (typeof this.onErrorCallback !== "function") {
+			throw new Error("setCallbacks() must be called before initialize()");
+		}
+
+		if (!this.config.apiKey) {
+			Log.error("[openweathermap] API key is required");
+			this.onErrorCallback({
+				message: "API key is required",
+				translationKey: "MODULE_ERROR_UNSPECIFIED"
+			});
+			return;
+		}
+
+		this.#initializeFetcher();
+	}
+
+	setCallbacks (onData, onError) {
+		this.onDataCallback = onData;
+		this.onErrorCallback = onError;
+	}
+
+	start () {
+		if (this.fetcher) {
+			this.fetcher.startPeriodicFetch();
+		}
+	}
+
+	stop () {
+		if (this.fetcher) {
+			this.fetcher.clearTimer();
+		}
+	}
+
+	#initializeFetcher () {
+		const url = this.#getUrl();
+
+		this.fetcher = new HTTPFetcher(url, {
+			reloadInterval: this.config.updateInterval,
+			headers: { "Cache-Control": "no-cache" },
+			logContext: "weatherprovider.openweathermap"
+		});
+
+		this.fetcher.on("response", async (response) => {
+			try {
+				const data = await response.json();
+				this.#handleResponse(data);
+			} catch (error) {
+				Log.error("[openweathermap] Failed to parse JSON:", error);
+				if (this.onErrorCallback) {
+					this.onErrorCallback({
+						message: "Failed to parse API response",
+						translationKey: "MODULE_ERROR_UNSPECIFIED"
+					});
+				}
+			}
+		});
+
+		this.fetcher.on("error", (errorInfo) => {
+			if (this.onErrorCallback) {
+				this.onErrorCallback(errorInfo);
+			}
+		});
+	}
+
+	#handleResponse (data) {
+		try {
+			// Set location name from timezone
+			if (data.timezone) {
+				this.locationName = data.timezone;
+			}
+
+			let weatherData;
+			const onecallData = this.#generateWeatherObjectsFromOnecall(data);
+
+			switch (this.config.type) {
+				case "current":
+					weatherData = onecallData.current;
+					break;
+				case "forecast":
+				case "daily":
+					weatherData = onecallData.days;
+					break;
+				case "hourly":
+					weatherData = onecallData.hours;
+					break;
+				default:
+					Log.error(`[openweathermap] Unknown type: ${this.config.type}`);
+					throw new Error(`Unknown weather type: ${this.config.type}`);
+			}
+
+			if (weatherData && this.onDataCallback) {
+				this.onDataCallback(weatherData);
+			}
+		} catch (error) {
+			Log.error("[openweathermap] Error processing weather data:", error);
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: error.message,
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+		}
+	}
+
+	#generateWeatherObjectsFromOnecall (data) {
+		let precip;
+
+		// Get current weather
+		const current = {};
+		if (data.hasOwnProperty("current")) {
+			const timezoneOffset = data.timezone_offset / 60;
+			current.date = weatherUtils.applyTimezoneOffset(new Date(data.current.dt * 1000), timezoneOffset);
+			current.windSpeed = data.current.wind_speed;
+			current.windFromDirection = data.current.wind_deg;
+			current.sunrise = weatherUtils.applyTimezoneOffset(new Date(data.current.sunrise * 1000), timezoneOffset);
+			current.sunset = weatherUtils.applyTimezoneOffset(new Date(data.current.sunset * 1000), timezoneOffset);
+			current.temperature = data.current.temp;
+			current.weatherType = weatherUtils.convertWeatherType(data.current.weather[0].icon);
+			current.humidity = data.current.humidity;
+			current.uvIndex = data.current.uvi;
+
+			precip = false;
+			if (data.current.hasOwnProperty("rain") && !isNaN(data.current.rain["1h"])) {
+				current.rain = data.current.rain["1h"];
+				precip = true;
+			}
+			if (data.current.hasOwnProperty("snow") && !isNaN(data.current.snow["1h"])) {
+				current.snow = data.current.snow["1h"];
+				precip = true;
+			}
+			if (precip) {
+				current.precipitationAmount = (current.rain ?? 0) + (current.snow ?? 0);
+			}
+			current.feelsLikeTemp = data.current.feels_like;
+		}
+
+		// Get hourly weather
+		const hours = [];
+		if (data.hasOwnProperty("hourly")) {
+			const timezoneOffset = data.timezone_offset / 60;
+			for (const hour of data.hourly) {
+				const weather = {};
+				weather.date = weatherUtils.applyTimezoneOffset(new Date(hour.dt * 1000), timezoneOffset);
+				weather.temperature = hour.temp;
+				weather.feelsLikeTemp = hour.feels_like;
+				weather.humidity = hour.humidity;
+				weather.windSpeed = hour.wind_speed;
+				weather.windFromDirection = hour.wind_deg;
+				weather.weatherType = weatherUtils.convertWeatherType(hour.weather[0].icon);
+				weather.precipitationProbability = hour.pop !== undefined ? hour.pop * 100 : undefined;
+				weather.uvIndex = hour.uvi;
+
+				precip = false;
+				if (hour.hasOwnProperty("rain") && !isNaN(hour.rain["1h"])) {
+					weather.rain = hour.rain["1h"];
+					precip = true;
+				}
+				if (hour.hasOwnProperty("snow") && !isNaN(hour.snow["1h"])) {
+					weather.snow = hour.snow["1h"];
+					precip = true;
+				}
+				if (precip) {
+					weather.precipitationAmount = (weather.rain ?? 0) + (weather.snow ?? 0);
+				}
+
+				hours.push(weather);
+			}
+		}
+
+		// Get daily weather
+		const days = [];
+		if (data.hasOwnProperty("daily")) {
+			const timezoneOffset = data.timezone_offset / 60;
+			for (const day of data.daily) {
+				const weather = {};
+				weather.date = weatherUtils.applyTimezoneOffset(new Date(day.dt * 1000), timezoneOffset);
+				weather.sunrise = weatherUtils.applyTimezoneOffset(new Date(day.sunrise * 1000), timezoneOffset);
+				weather.sunset = weatherUtils.applyTimezoneOffset(new Date(day.sunset * 1000), timezoneOffset);
+				weather.minTemperature = day.temp.min;
+				weather.maxTemperature = day.temp.max;
+				weather.humidity = day.humidity;
+				weather.windSpeed = day.wind_speed;
+				weather.windFromDirection = day.wind_deg;
+				weather.weatherType = weatherUtils.convertWeatherType(day.weather[0].icon);
+				weather.precipitationProbability = day.pop !== undefined ? day.pop * 100 : undefined;
+				weather.uvIndex = day.uvi;
+
+				precip = false;
+				if (!isNaN(day.rain)) {
+					weather.rain = day.rain;
+					precip = true;
+				}
+				if (!isNaN(day.snow)) {
+					weather.snow = day.snow;
+					precip = true;
+				}
+				if (precip) {
+					weather.precipitationAmount = (weather.rain ?? 0) + (weather.snow ?? 0);
+				}
+
+				days.push(weather);
+			}
+		}
+
+		return { current, hours, days };
+	}
+
+	#getUrl () {
+		return this.config.apiBase + this.config.apiVersion + this.config.weatherEndpoint + this.#getParams();
+	}
+
+	#getParams () {
+		let params = "?";
+
+		if (this.config.weatherEndpoint === "/onecall") {
+			params += `lat=${this.config.lat}`;
+			params += `&lon=${this.config.lon}`;
+
+			if (this.config.type === "current") {
+				params += "&exclude=minutely,hourly,daily";
+			} else if (this.config.type === "hourly") {
+				params += "&exclude=current,minutely,daily";
+			} else if (this.config.type === "daily" || this.config.type === "forecast") {
+				params += "&exclude=current,minutely,hourly";
+			} else {
+				params += "&exclude=minutely";
+			}
+		} else if (this.config.lat && this.config.lon) {
+			params += `lat=${this.config.lat}&lon=${this.config.lon}`;
+		} else if (this.config.locationID) {
+			params += `id=${this.config.locationID}`;
+		} else if (this.config.location) {
+			params += `q=${this.config.location}`;
+		}
+
+		params += "&units=metric";
+		params += `&lang=${this.config.lang || "en"}`;
+		params += `&APPID=${this.config.apiKey}`;
+
+		return params;
+	}
+}
+
+module.exports = OpenWeatherMapProvider;

defaultmodules/weather/providers/pirateweather.js

@@ -0,0 +1,270 @@
+const Log = require("logger");
+const HTTPFetcher = require("#http_fetcher");
+
+class PirateweatherProvider {
+	constructor (config) {
+		this.config = {
+			apiBase: "https://api.pirateweather.net",
+			weatherEndpoint: "/forecast",
+			apiKey: "",
+			lat: 0,
+			lon: 0,
+			type: "current",
+			updateInterval: 10 * 60 * 1000,
+			lang: "en",
+			...config
+		};
+		this.fetcher = null;
+		this.onDataCallback = null;
+		this.onErrorCallback = null;
+	}
+
+	setCallbacks (onDataCallback, onErrorCallback) {
+		this.onDataCallback = onDataCallback;
+		this.onErrorCallback = onErrorCallback;
+	}
+
+	initialize () {
+		if (!this.config.apiKey) {
+			Log.error("[pirateweather] No API key configured");
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: "API key required",
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+			return;
+		}
+
+		this.#initializeFetcher();
+	}
+
+	#initializeFetcher () {
+		const url = this.#getUrl();
+
+		this.fetcher = new HTTPFetcher(url, {
+			reloadInterval: this.config.updateInterval,
+			headers: {
+				"Cache-Control": "no-cache",
+				Accept: "application/json"
+			},
+			logContext: "weatherprovider.pirateweather"
+		});
+
+		this.fetcher.on("response", async (response) => {
+			try {
+				const data = await response.json();
+				this.#handleResponse(data);
+			} catch (error) {
+				Log.error("[pirateweather] Parse error:", error);
+				if (this.onErrorCallback) {
+					this.onErrorCallback({
+						message: "Failed to parse API response",
+						translationKey: "MODULE_ERROR_UNSPECIFIED"
+					});
+				}
+			}
+		});
+
+		this.fetcher.on("error", (errorInfo) => {
+			if (this.onErrorCallback) {
+				this.onErrorCallback(errorInfo);
+			}
+		});
+	}
+
+	#handleResponse (data) {
+		if (!data || (!data.currently && !data.daily && !data.hourly)) {
+			Log.error("[pirateweather] No usable data received");
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: "No usable data in API response",
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+			return;
+		}
+
+		let weatherData;
+
+		switch (this.config.type) {
+			case "current":
+				weatherData = this.#generateCurrent(data);
+				break;
+			case "forecast":
+			case "daily":
+				weatherData = this.#generateDaily(data);
+				break;
+			case "hourly":
+				weatherData = this.#generateHourly(data);
+				break;
+			default:
+				Log.error(`[pirateweather] Unknown weather type: ${this.config.type}`);
+				if (this.onErrorCallback) {
+					this.onErrorCallback({
+						message: `Unknown weather type: ${this.config.type}`,
+						translationKey: "MODULE_ERROR_UNSPECIFIED"
+					});
+				}
+				return;
+
+		}
+
+		if (weatherData && this.onDataCallback) {
+			this.onDataCallback(weatherData);
+		}
+	}
+
+	#generateCurrent (data) {
+		if (!data.currently || typeof data.currently.temperature === "undefined") {
+			return null;
+		}
+
+		const current = {
+			date: new Date(),
+			humidity: data.currently.humidity != null ? parseFloat(data.currently.humidity) * 100 : null,
+			temperature: parseFloat(data.currently.temperature),
+			feelsLikeTemp: data.currently.apparentTemperature != null ? parseFloat(data.currently.apparentTemperature) : null,
+			windSpeed: data.currently.windSpeed != null ? parseFloat(data.currently.windSpeed) : null,
+			windFromDirection: data.currently.windBearing || null,
+			weatherType: this.#convertWeatherType(data.currently.icon),
+			sunrise: null,
+			sunset: null
+		};
+
+		// Add sunrise/sunset from daily data if available
+		if (data.daily && data.daily.data && data.daily.data.length > 0) {
+			const today = data.daily.data[0];
+			if (today.sunriseTime) {
+				current.sunrise = new Date(today.sunriseTime * 1000);
+			}
+			if (today.sunsetTime) {
+				current.sunset = new Date(today.sunsetTime * 1000);
+			}
+		}
+
+		return current;
+	}
+
+	#generateDaily (data) {
+		if (!data.daily || !data.daily.data || !data.daily.data.length) {
+			return [];
+		}
+
+		const days = [];
+
+		for (const forecast of data.daily.data) {
+			const day = {
+				date: new Date(forecast.time * 1000),
+				minTemperature: forecast.temperatureMin != null ? parseFloat(forecast.temperatureMin) : null,
+				maxTemperature: forecast.temperatureMax != null ? parseFloat(forecast.temperatureMax) : null,
+				weatherType: this.#convertWeatherType(forecast.icon),
+				snow: 0,
+				rain: 0,
+				precipitationAmount: 0,
+				precipitationProbability: forecast.precipProbability != null ? parseFloat(forecast.precipProbability) * 100 : null
+			};
+
+			// Handle precipitation
+			let precip = 0;
+			if (forecast.hasOwnProperty("precipAccumulation")) {
+				precip = forecast.precipAccumulation * 10; // cm to mm
+			}
+
+			day.precipitationAmount = precip;
+
+			if (forecast.precipType) {
+				if (forecast.precipType === "snow") {
+					day.snow = precip;
+				} else {
+					day.rain = precip;
+				}
+			}
+
+			days.push(day);
+		}
+
+		return days;
+	}
+
+	#generateHourly (data) {
+		if (!data.hourly || !data.hourly.data || !data.hourly.data.length) {
+			return [];
+		}
+
+		const hours = [];
+
+		for (const forecast of data.hourly.data) {
+			const hour = {
+				date: new Date(forecast.time * 1000),
+				temperature: forecast.temperature !== undefined ? parseFloat(forecast.temperature) : null,
+				feelsLikeTemp: forecast.apparentTemperature !== undefined ? parseFloat(forecast.apparentTemperature) : null,
+				weatherType: this.#convertWeatherType(forecast.icon),
+				windSpeed: forecast.windSpeed !== undefined ? parseFloat(forecast.windSpeed) : null,
+				windFromDirection: forecast.windBearing || null,
+				precipitationProbability: forecast.precipProbability ? parseFloat(forecast.precipProbability) * 100 : null,
+				snow: 0,
+				rain: 0,
+				precipitationAmount: 0
+			};
+
+			// Handle precipitation
+			let precip = 0;
+			if (forecast.hasOwnProperty("precipAccumulation")) {
+				precip = forecast.precipAccumulation * 10; // cm to mm
+			}
+
+			hour.precipitationAmount = precip;
+
+			if (forecast.precipType) {
+				if (forecast.precipType === "snow") {
+					hour.snow = precip;
+				} else {
+					hour.rain = precip;
+				}
+			}
+
+			hours.push(hour);
+		}
+
+		return hours;
+	}
+
+	#getUrl () {
+		const apiBase = this.config.apiBase || "https://api.pirateweather.net";
+		const weatherEndpoint = this.config.weatherEndpoint || "/forecast";
+		const lang = this.config.lang || "en";
+		return `${apiBase}${weatherEndpoint}/${this.config.apiKey}/${this.config.lat},${this.config.lon}?units=si&lang=${lang}`;
+	}
+
+	#convertWeatherType (weatherType) {
+		const weatherTypes = {
+			"clear-day": "day-sunny",
+			"clear-night": "night-clear",
+			rain: "rain",
+			snow: "snow",
+			sleet: "snow",
+			wind: "windy",
+			fog: "fog",
+			cloudy: "cloudy",
+			"partly-cloudy-day": "day-cloudy",
+			"partly-cloudy-night": "night-cloudy"
+		};
+
+		return weatherTypes[weatherType] || null;
+	}
+
+	start () {
+		if (this.fetcher) {
+			this.fetcher.startPeriodicFetch();
+		}
+	}
+
+	stop () {
+		if (this.fetcher) {
+			this.fetcher.clearTimer();
+		}
+	}
+}
+
+module.exports = PirateweatherProvider;

defaultmodules/weather/providers/smhi.js

@@ -0,0 +1,397 @@
+const Log = require("logger");
+const { getSunTimes, isDayTime, validateCoordinates } = require("../provider-utils");
+const HTTPFetcher = require("#http_fetcher");
+
+/**
+ * Server-side weather provider for SMHI (Swedish Meteorological and Hydrological Institute)
+ * Sweden only, metric system
+ * API: https://opendata.smhi.se/apidocs/metfcst/
+ */
+class SMHIProvider {
+	constructor (config) {
+		this.config = {
+			lat: 0,
+			lon: 0,
+			precipitationValue: "pmedian", // pmin, pmean, pmedian, pmax
+			type: "current",
+			updateInterval: 5 * 60 * 1000,
+			...config
+		};
+
+		// Validate precipitationValue
+		if (!["pmin", "pmean", "pmedian", "pmax"].includes(this.config.precipitationValue)) {
+			Log.warn(`[smhi] Invalid precipitationValue: ${this.config.precipitationValue}, using pmedian`);
+			this.config.precipitationValue = "pmedian";
+		}
+
+		this.fetcher = null;
+		this.onDataCallback = null;
+		this.onErrorCallback = null;
+	}
+
+	initialize () {
+		try {
+			// SMHI requires max 6 decimal places
+			validateCoordinates(this.config, 6);
+			this.#initializeFetcher();
+		} catch (error) {
+			Log.error("[smhi] Initialization failed:", error);
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: error.message,
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+		}
+	}
+
+	setCallbacks (onData, onError) {
+		this.onDataCallback = onData;
+		this.onErrorCallback = onError;
+	}
+
+	start () {
+		if (this.fetcher) {
+			this.fetcher.startPeriodicFetch();
+		}
+	}
+
+	stop () {
+		if (this.fetcher) {
+			this.fetcher.clearTimer();
+		}
+	}
+
+	#initializeFetcher () {
+		const url = this.#getUrl();
+
+		this.fetcher = new HTTPFetcher(url, {
+			reloadInterval: this.config.updateInterval,
+			logContext: "weatherprovider.smhi"
+		});
+
+		this.fetcher.on("response", async (response) => {
+			try {
+				const data = await response.json();
+				this.#handleResponse(data);
+			} catch (error) {
+				Log.error("[smhi] Failed to parse JSON:", error);
+				if (this.onErrorCallback) {
+					this.onErrorCallback({
+						message: "Failed to parse API response",
+						translationKey: "MODULE_ERROR_UNSPECIFIED"
+					});
+				}
+			}
+		});
+
+		this.fetcher.on("error", (errorInfo) => {
+			if (this.onErrorCallback) {
+				this.onErrorCallback(errorInfo);
+			}
+		});
+	}
+
+	#handleResponse (data) {
+		try {
+			if (!data.timeSeries || !Array.isArray(data.timeSeries)) {
+				throw new Error("Invalid weather data");
+			}
+
+			const coordinates = this.#resolveCoordinates(data);
+			let weatherData;
+
+			switch (this.config.type) {
+				case "current":
+					weatherData = this.#generateCurrentWeather(data.timeSeries, coordinates);
+					break;
+				case "forecast":
+				case "daily":
+					weatherData = this.#generateForecast(data.timeSeries, coordinates);
+					break;
+				case "hourly":
+					weatherData = this.#generateHourly(data.timeSeries, coordinates);
+					break;
+				default:
+					Log.error(`[smhi] Unknown weather type: ${this.config.type}`);
+					if (this.onErrorCallback) {
+						this.onErrorCallback({
+							message: `Unknown weather type: ${this.config.type}`,
+							translationKey: "MODULE_ERROR_UNSPECIFIED"
+						});
+					}
+					return;
+			}
+
+			if (this.onDataCallback) {
+				this.onDataCallback(weatherData);
+			}
+		} catch (error) {
+			Log.error("[smhi] Error processing weather data:", error);
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: error.message,
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+		}
+	}
+
+	#generateCurrentWeather (timeSeries, coordinates) {
+		const closest = this.#getClosestToCurrentTime(timeSeries);
+		return this.#convertWeatherDataToObject(closest, coordinates);
+	}
+
+	#generateForecast (timeSeries, coordinates) {
+		const filled = this.#fillInGaps(timeSeries);
+		return this.#convertWeatherDataGroupedBy(filled, coordinates, "day");
+	}
+
+	#generateHourly (timeSeries, coordinates) {
+		const filled = this.#fillInGaps(timeSeries);
+		return this.#convertWeatherDataGroupedBy(filled, coordinates, "hour");
+	}
+
+	#getClosestToCurrentTime (times) {
+		const now = new Date();
+		let minDiff = null;
+		let closest = times[0];
+
+		for (const time of times) {
+			const validTime = new Date(time.validTime);
+			const diff = Math.abs(validTime - now);
+
+			if (minDiff === null || diff < minDiff) {
+				minDiff = diff;
+				closest = time;
+			}
+		}
+
+		return closest;
+	}
+
+	#convertWeatherDataToObject (weatherData, coordinates) {
+		const date = new Date(weatherData.validTime);
+		const { sunrise, sunset } = getSunTimes(date, coordinates.lat, coordinates.lon);
+		const isDay = isDayTime(date, sunrise, sunset);
+
+		const current = {
+			date: date,
+			humidity: this.#paramValue(weatherData, "r"),
+			temperature: this.#paramValue(weatherData, "t"),
+			windSpeed: this.#paramValue(weatherData, "ws"),
+			windFromDirection: this.#paramValue(weatherData, "wd"),
+			weatherType: this.#convertWeatherType(this.#paramValue(weatherData, "Wsymb2"), isDay),
+			feelsLikeTemp: this.#calculateApparentTemperature(weatherData),
+			sunrise: sunrise,
+			sunset: sunset,
+			snow: 0,
+			rain: 0,
+			precipitationAmount: 0
+		};
+
+		// Determine precipitation amount and category
+		const precipitationValue = this.#paramValue(weatherData, this.config.precipitationValue);
+		const pcat = this.#paramValue(weatherData, "pcat");
+
+		switch (pcat) {
+			case 1: // Snow
+				current.snow = precipitationValue;
+				current.precipitationAmount = precipitationValue;
+				break;
+			case 2: // Snow and rain (50/50 split)
+				current.snow = precipitationValue / 2;
+				current.rain = precipitationValue / 2;
+				current.precipitationAmount = precipitationValue;
+				break;
+			case 3: // Rain
+			case 4: // Drizzle
+			case 5: // Freezing rain
+			case 6: // Freezing drizzle
+				current.rain = precipitationValue;
+				current.precipitationAmount = precipitationValue;
+				break;
+			// case 0: No precipitation - defaults already set to 0
+		}
+
+		return current;
+	}
+
+	#convertWeatherDataGroupedBy (allWeatherData, coordinates, groupBy = "day") {
+		const result = [];
+		let currentWeather = null;
+		let dayWeatherTypes = [];
+
+		const allWeatherObjects = allWeatherData.map((data) => this.#convertWeatherDataToObject(data, coordinates));
+
+		for (const weatherObject of allWeatherObjects) {
+			const objDate = new Date(weatherObject.date);
+
+			// Check if we need a new group (day or hour change)
+			const needNewGroup = !currentWeather || !this.#isSamePeriod(currentWeather.date, objDate, groupBy);
+
+			if (needNewGroup) {
+				currentWeather = {
+					date: objDate,
+					temperature: weatherObject.temperature,
+					minTemperature: Infinity,
+					maxTemperature: -Infinity,
+					snow: 0,
+					rain: 0,
+					precipitationAmount: 0,
+					sunrise: weatherObject.sunrise,
+					sunset: weatherObject.sunset
+				};
+				dayWeatherTypes = [];
+				result.push(currentWeather);
+			}
+
+			// Track weather types during daytime
+			const { sunrise: daySunrise, sunset: daySunset } = getSunTimes(objDate, coordinates.lat, coordinates.lon);
+			const isDay = isDayTime(objDate, daySunrise, daySunset);
+
+			if (isDay) {
+				dayWeatherTypes.push(weatherObject.weatherType);
+			}
+
+			// Use median weather type from daytime hours
+			if (dayWeatherTypes.length > 0) {
+				currentWeather.weatherType = dayWeatherTypes[Math.floor(dayWeatherTypes.length / 2)];
+			} else {
+				currentWeather.weatherType = weatherObject.weatherType;
+			}
+
+			// Aggregate min/max and precipitation
+			currentWeather.minTemperature = Math.min(currentWeather.minTemperature, weatherObject.temperature);
+			currentWeather.maxTemperature = Math.max(currentWeather.maxTemperature, weatherObject.temperature);
+			currentWeather.snow += weatherObject.snow;
+			currentWeather.rain += weatherObject.rain;
+			currentWeather.precipitationAmount += weatherObject.precipitationAmount;
+		}
+
+		return result;
+	}
+
+	#isSamePeriod (date1, date2, groupBy) {
+		if (groupBy === "hour") {
+			return date1.getFullYear() === date2.getFullYear()
+			  && date1.getMonth() === date2.getMonth()
+			  && date1.getDate() === date2.getDate()
+			  && date1.getHours() === date2.getHours();
+		} else { // day
+			return date1.getFullYear() === date2.getFullYear()
+			  && date1.getMonth() === date2.getMonth()
+			  && date1.getDate() === date2.getDate();
+		}
+	}
+
+	#fillInGaps (data) {
+		if (data.length === 0) return [];
+
+		const result = [];
+		result.push(data[0]); // Keep first data point
+
+		for (let i = 1; i < data.length; i++) {
+			const from = new Date(data[i - 1].validTime);
+			const to = new Date(data[i].validTime);
+			const hours = Math.floor((to - from) / (1000 * 60 * 60));
+
+			// Fill gaps with previous data point (start at j=1 since j=0 is already pushed)
+			for (let j = 1; j < hours; j++) {
+				const current = { ...data[i - 1] };
+				const newTime = new Date(from);
+				newTime.setHours(from.getHours() + j);
+				current.validTime = newTime.toISOString();
+				result.push(current);
+			}
+
+			// Push original data point
+			result.push(data[i]);
+		}
+
+		return result;
+	}
+
+	#resolveCoordinates (data) {
+		// SMHI returns coordinates in [lon, lat] format
+		// Fall back to config if response structure is unexpected
+		if (data?.geometry?.coordinates?.[0] && Array.isArray(data.geometry.coordinates[0]) && data.geometry.coordinates[0].length >= 2) {
+			return {
+				lat: data.geometry.coordinates[0][1],
+				lon: data.geometry.coordinates[0][0]
+			};
+		}
+
+		Log.warn("[smhi] Invalid coordinate structure in response, using config values");
+		return {
+			lat: this.config.lat,
+			lon: this.config.lon
+		};
+	}
+
+	#calculateApparentTemperature (weatherData) {
+		const Ta = this.#paramValue(weatherData, "t");
+		const rh = this.#paramValue(weatherData, "r");
+		const ws = this.#paramValue(weatherData, "ws");
+		const p = (rh / 100) * 6.105 * Math.exp((17.27 * Ta) / (237.7 + Ta));
+
+		return Ta + 0.33 * p - 0.7 * ws - 4;
+	}
+
+	#paramValue (weatherData, name) {
+		const param = weatherData.parameters.find((p) => p.name === name);
+		return param ? param.values[0] : null;
+	}
+
+	#convertWeatherType (input, isDayTime) {
+		switch (input) {
+			case 1:
+				return isDayTime ? "day-sunny" : "night-clear"; // Clear sky
+			case 2:
+				return isDayTime ? "day-sunny-overcast" : "night-partly-cloudy"; // Nearly clear sky
+			case 3:
+			case 4:
+				return isDayTime ? "day-cloudy" : "night-cloudy"; // Variable/halfclear cloudiness
+			case 5:
+			case 6:
+				return "cloudy"; // Cloudy/overcast
+			case 7:
+				return "fog";
+			case 8:
+			case 9:
+			case 10:
+				return "showers"; // Light/moderate/heavy rain showers
+			case 11:
+			case 21:
+				return "thunderstorm";
+			case 12:
+			case 13:
+			case 14:
+			case 22:
+			case 23:
+			case 24:
+				return "sleet"; // Light/moderate/heavy sleet (showers)
+			case 15:
+			case 16:
+			case 17:
+			case 25:
+			case 26:
+			case 27:
+				return "snow"; // Light/moderate/heavy snow (showers/fall)
+			case 18:
+			case 19:
+			case 20:
+				return "rain"; // Light/moderate/heavy rain
+			default:
+				return null;
+		}
+	}
+
+	#getUrl () {
+		const lon = this.config.lon.toFixed(6);
+		const lat = this.config.lat.toFixed(6);
+		return `https://opendata-download-metfcst.smhi.se/api/category/pmp3g/version/2/geotype/point/lon/${lon}/lat/${lat}/data.json`;
+	}
+}
+
+module.exports = SMHIProvider;

defaultmodules/weather/providers/ukmetofficedatahub.js

@@ -0,0 +1,329 @@
+const Log = require("logger");
+const { getSunTimes } = require("../provider-utils");
+const HTTPFetcher = require("#http_fetcher");
+
+/**
+ * UK Met Office Data Hub provider
+ * For more information: https://www.metoffice.gov.uk/services/data/datapoint/notifications/weather-datahub
+ *
+ * Data available:
+ * - Hourly data for next 2 days (for current weather)
+ * - 3-hourly data for next 7 days (for hourly forecasts)
+ * - Daily data for next 7 days (for daily forecasts)
+ *
+ * Free accounts limited to 360 requests/day per service (once every 4 minutes)
+ */
+class UkMetOfficeDataHubProvider {
+	constructor (config) {
+		this.config = {
+			apiBase: "https://data.hub.api.metoffice.gov.uk/sitespecific/v0/point/",
+			apiKey: "",
+			lat: 0,
+			lon: 0,
+			type: "current",
+			updateInterval: 10 * 60 * 1000,
+			...config
+		};
+
+		this.fetcher = null;
+		this.onDataCallback = null;
+		this.onErrorCallback = null;
+	}
+
+	setCallbacks (onDataCallback, onErrorCallback) {
+		this.onDataCallback = onDataCallback;
+		this.onErrorCallback = onErrorCallback;
+	}
+
+	initialize () {
+		if (!this.config.apiKey || this.config.apiKey === "YOUR_API_KEY_HERE") {
+			Log.error("[ukmetofficedatahub] No API key configured");
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: "UK Met Office DataHub API key required. Get one at https://datahub.metoffice.gov.uk/",
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+			return;
+		}
+
+		this.#initializeFetcher();
+	}
+
+	#initializeFetcher () {
+		const forecastType = this.#getForecastType();
+		const url = this.#getUrl(forecastType);
+
+		this.fetcher = new HTTPFetcher(url, {
+			reloadInterval: this.config.updateInterval,
+			headers: {
+				Accept: "application/json",
+				apikey: this.config.apiKey
+			},
+			logContext: "weatherprovider.ukmetofficedatahub"
+		});
+
+		this.fetcher.on("response", async (response) => {
+			try {
+				const data = await response.json();
+				this.#handleResponse(data);
+			} catch (error) {
+				Log.error("[ukmetofficedatahub] Parse error:", error);
+				if (this.onErrorCallback) {
+					this.onErrorCallback({
+						message: "Failed to parse API response",
+						translationKey: "MODULE_ERROR_UNSPECIFIED"
+					});
+				}
+			}
+		});
+
+		this.fetcher.on("error", (errorInfo) => {
+			if (this.onErrorCallback) {
+				this.onErrorCallback(errorInfo);
+			}
+		});
+	}
+
+	#getForecastType () {
+		switch (this.config.type) {
+			case "hourly":
+				return "three-hourly";
+			case "forecast":
+			case "daily":
+				return "daily";
+			case "current":
+			default:
+				return "hourly";
+		}
+	}
+
+	#getUrl (forecastType) {
+		const base = this.config.apiBase.endsWith("/") ? this.config.apiBase : `${this.config.apiBase}/`;
+		const queryStrings = `?latitude=${this.config.lat}&longitude=${this.config.lon}&includeLocationName=true`;
+		return `${base}${forecastType}${queryStrings}`;
+	}
+
+	#handleResponse (data) {
+		if (!data || !data.features || !data.features[0] || !data.features[0].properties || !data.features[0].properties.timeSeries || data.features[0].properties.timeSeries.length === 0) {
+			Log.error("[ukmetofficedatahub] No usable data received");
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: "No usable data in API response",
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+			return;
+		}
+
+		let weatherData;
+
+		switch (this.config.type) {
+			case "current":
+				weatherData = this.#generateCurrent(data);
+				break;
+			case "forecast":
+			case "daily":
+				weatherData = this.#generateDaily(data);
+				break;
+			case "hourly":
+				weatherData = this.#generateHourly(data);
+				break;
+			default:
+				Log.error(`[ukmetofficedatahub] Unknown weather type: ${this.config.type}`);
+				if (this.onErrorCallback) {
+					this.onErrorCallback({
+						message: `Unknown weather type: ${this.config.type}`,
+						translationKey: "MODULE_ERROR_UNSPECIFIED"
+					});
+				}
+				return;
+		}
+
+		if (weatherData && this.onDataCallback) {
+			this.onDataCallback(weatherData);
+		}
+	}
+
+	#generateCurrent (data) {
+		const timeSeries = data.features[0].properties.timeSeries;
+		const now = new Date();
+
+		// Find the hour that contains current time
+		for (const hour of timeSeries) {
+			const forecastTime = new Date(hour.time);
+			const oneHourLater = new Date(forecastTime.getTime() + 60 * 60 * 1000);
+
+			if (now >= forecastTime && now < oneHourLater) {
+				const current = {
+					date: forecastTime,
+					temperature: hour.screenTemperature || null,
+					minTemperature: hour.minScreenAirTemp || null,
+					maxTemperature: hour.maxScreenAirTemp || null,
+					windSpeed: hour.windSpeed10m || null,
+					windFromDirection: hour.windDirectionFrom10m || null,
+					weatherType: this.#convertWeatherType(hour.significantWeatherCode),
+					humidity: hour.screenRelativeHumidity || null,
+					rain: hour.totalPrecipAmount || 0,
+					snow: hour.totalSnowAmount || 0,
+					precipitationAmount: (hour.totalPrecipAmount || 0) + (hour.totalSnowAmount || 0),
+					precipitationProbability: hour.probOfPrecipitation || null,
+					feelsLikeTemp: hour.feelsLikeTemperature || null,
+					sunrise: null,
+					sunset: null
+				};
+
+				// Calculate sunrise/sunset using SunCalc
+				const { sunrise, sunset } = getSunTimes(now, this.config.lat, this.config.lon);
+				current.sunrise = sunrise;
+				current.sunset = sunset;
+
+				return current;
+			}
+		}
+
+		// Fallback to first hour if no match found
+		const firstHour = timeSeries[0];
+		const current = {
+			date: new Date(firstHour.time),
+			temperature: firstHour.screenTemperature || null,
+			windSpeed: firstHour.windSpeed10m || null,
+			windFromDirection: firstHour.windDirectionFrom10m || null,
+			weatherType: this.#convertWeatherType(firstHour.significantWeatherCode),
+			humidity: firstHour.screenRelativeHumidity || null,
+			rain: firstHour.totalPrecipAmount || 0,
+			snow: firstHour.totalSnowAmount || 0,
+			precipitationAmount: (firstHour.totalPrecipAmount || 0) + (firstHour.totalSnowAmount || 0),
+			precipitationProbability: firstHour.probOfPrecipitation || null,
+			feelsLikeTemp: firstHour.feelsLikeTemperature || null,
+			sunrise: null,
+			sunset: null
+		};
+
+		const { sunrise, sunset } = getSunTimes(now, this.config.lat, this.config.lon);
+		current.sunrise = sunrise;
+		current.sunset = sunset;
+
+		return current;
+	}
+
+	#generateDaily (data) {
+		const timeSeries = data.features[0].properties.timeSeries;
+		const days = [];
+		const today = new Date();
+		today.setHours(0, 0, 0, 0);
+
+		for (const day of timeSeries) {
+			const forecastDate = new Date(day.time);
+			forecastDate.setHours(0, 0, 0, 0);
+
+			// Only include today and future days
+			if (forecastDate >= today) {
+				days.push({
+					date: new Date(day.time),
+					minTemperature: day.nightMinScreenTemperature || null,
+					maxTemperature: day.dayMaxScreenTemperature || null,
+					temperature: day.dayMaxScreenTemperature || null,
+					windSpeed: day.midday10MWindSpeed || null,
+					windFromDirection: day.midday10MWindDirection || null,
+					weatherType: this.#convertWeatherType(day.daySignificantWeatherCode),
+					humidity: day.middayRelativeHumidity || null,
+					rain: day.dayProbabilityOfRain || 0,
+					snow: day.dayProbabilityOfSnow || 0,
+					precipitationAmount: 0,
+					precipitationProbability: day.dayProbabilityOfPrecipitation || null,
+					feelsLikeTemp: day.dayMaxFeelsLikeTemp || null
+				});
+			}
+		}
+
+		return days;
+	}
+
+	#generateHourly (data) {
+		const timeSeries = data.features[0].properties.timeSeries;
+		const hours = [];
+
+		for (const hour of timeSeries) {
+			// 3-hourly data uses maxScreenAirTemp/minScreenAirTemp, not screenTemperature
+			const temp = hour.screenTemperature !== undefined
+				? hour.screenTemperature
+				: (hour.maxScreenAirTemp !== undefined && hour.minScreenAirTemp !== undefined)
+					? (hour.maxScreenAirTemp + hour.minScreenAirTemp) / 2
+					: null;
+
+			hours.push({
+				date: new Date(hour.time),
+				temperature: temp,
+				windSpeed: hour.windSpeed10m || null,
+				windFromDirection: hour.windDirectionFrom10m || null,
+				weatherType: this.#convertWeatherType(hour.significantWeatherCode),
+				humidity: hour.screenRelativeHumidity || null,
+				rain: hour.totalPrecipAmount || 0,
+				snow: hour.totalSnowAmount || 0,
+				precipitationAmount: (hour.totalPrecipAmount || 0) + (hour.totalSnowAmount || 0),
+				precipitationProbability: hour.probOfPrecipitation || null,
+				feelsLikeTemp: hour.feelsLikeTemp || null
+			});
+		}
+
+		return hours;
+	}
+
+	/**
+	 * Convert Met Office significant weather code to weathericons.css icon
+	 * See: https://metoffice.apiconnect.ibmcloud.com/metoffice/production/node/264
+	 * @param {number} weatherType - Met Office weather code
+	 * @returns {string|null} Weathericons.css icon name or null
+	 */
+	#convertWeatherType (weatherType) {
+		const weatherTypes = {
+			0: "night-clear",
+			1: "day-sunny",
+			2: "night-alt-cloudy",
+			3: "day-cloudy",
+			5: "fog",
+			6: "fog",
+			7: "cloudy",
+			8: "cloud",
+			9: "night-sprinkle",
+			10: "day-sprinkle",
+			11: "raindrops",
+			12: "sprinkle",
+			13: "night-alt-showers",
+			14: "day-showers",
+			15: "rain",
+			16: "night-alt-sleet",
+			17: "day-sleet",
+			18: "sleet",
+			19: "night-alt-hail",
+			20: "day-hail",
+			21: "hail",
+			22: "night-alt-snow",
+			23: "day-snow",
+			24: "snow",
+			25: "night-alt-snow",
+			26: "day-snow",
+			27: "snow",
+			28: "night-alt-thunderstorm",
+			29: "day-thunderstorm",
+			30: "thunderstorm"
+		};
+
+		return weatherTypes[weatherType] || null;
+	}
+
+	start () {
+		if (this.fetcher) {
+			this.fetcher.startPeriodicFetch();
+		}
+	}
+
+	stop () {
+		if (this.fetcher) {
+			this.fetcher.clearTimer();
+		}
+	}
+}
+
+module.exports = UkMetOfficeDataHubProvider;

defaultmodules/weather/providers/weatherapi.js

@@ -0,0 +1,490 @@
+const Log = require("logger");
+const { convertKmhToMs, cardinalToDegrees } = require("../provider-utils");
+const HTTPFetcher = require("#http_fetcher");
+
+const WEATHER_API_BASE = "https://api.weatherapi.com/v1";
+
+class WeatherAPIProvider {
+	constructor (config) {
+		this.config = {
+			apiBase: WEATHER_API_BASE,
+			lat: 0,
+			lon: 0,
+			type: "current",
+			apiKey: "",
+			lang: "en",
+			maxEntries: 5,
+			maxNumberOfDays: 5,
+			updateInterval: 10 * 60 * 1000,
+			...config
+		};
+
+		this.locationName = null;
+		this.fetcher = null;
+		this.onDataCallback = null;
+		this.onErrorCallback = null;
+	}
+
+	initialize () {
+		this.#validateConfig();
+		this.#initializeFetcher();
+	}
+
+	setCallbacks (onData, onError) {
+		this.onDataCallback = onData;
+		this.onErrorCallback = onError;
+	}
+
+	start () {
+		if (this.fetcher) {
+			this.fetcher.startPeriodicFetch();
+		}
+	}
+
+	stop () {
+		if (this.fetcher) {
+			this.fetcher.clearTimer();
+		}
+	}
+
+	#validateConfig () {
+		this.config.type = `${this.config.type ?? ""}`.trim().toLowerCase();
+
+		if (this.config.type === "forecast") {
+			this.config.type = "daily";
+		}
+
+		if (!["hourly", "daily", "current"].includes(this.config.type)) {
+			throw new Error(`Unknown weather type: ${this.config.type}`);
+		}
+
+		if (!this.config.apiKey || `${this.config.apiKey}`.trim() === "") {
+			throw new Error("apiKey is required");
+		}
+
+		if (!Number.isFinite(this.config.lat) || !Number.isFinite(this.config.lon)) {
+			throw new Error("Latitude and longitude are required");
+		}
+	}
+
+	#initializeFetcher () {
+		const url = this.#getUrl();
+
+		this.fetcher = new HTTPFetcher(url, {
+			reloadInterval: this.config.updateInterval,
+			headers: { "Cache-Control": "no-cache" },
+			logContext: "weatherprovider.weatherapi"
+		});
+
+		this.fetcher.on("response", async (response) => {
+			try {
+				const data = await response.json();
+				this.#handleResponse(data);
+			} catch (error) {
+				Log.error("[weatherapi] Failed to parse JSON:", error);
+				if (this.onErrorCallback) {
+					this.onErrorCallback({
+						message: "Failed to parse API response",
+						translationKey: "MODULE_ERROR_UNSPECIFIED"
+					});
+				}
+			}
+		});
+
+		this.fetcher.on("error", (errorInfo) => {
+			if (this.onErrorCallback) {
+				this.onErrorCallback(errorInfo);
+			}
+		});
+	}
+
+	#handleResponse (data) {
+		let parsedData;
+
+		try {
+			parsedData = this.#parseResponse(data);
+		} catch (error) {
+			Log.error("[weatherapi] Invalid API response:", error);
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: "Invalid API response",
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+			return;
+		}
+
+		try {
+			let weatherData;
+
+			switch (this.config.type) {
+				case "current":
+					weatherData = this.#generateCurrent(parsedData);
+					break;
+				case "daily":
+					weatherData = this.#generateDaily(parsedData);
+					break;
+				case "hourly":
+					weatherData = this.#generateHourly(parsedData);
+					break;
+				default:
+					throw new Error(`Unknown weather type: ${this.config.type}`);
+			}
+
+			if (this.onDataCallback && weatherData) {
+				this.onDataCallback(weatherData);
+			}
+		} catch (error) {
+			Log.error("[weatherapi] Error processing weather data:", error);
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: error.message,
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+		}
+	}
+
+	#getQueryParameters () {
+		const maxEntries = Number.isFinite(this.config.maxEntries)
+			? Math.max(1, this.config.maxEntries)
+			: 5;
+
+		const requestedDays = Number.isFinite(this.config.maxNumberOfDays)
+			? Math.max(1, this.config.maxNumberOfDays)
+			: 5;
+
+		const hourlyDays = Math.max(1, Math.ceil(maxEntries / 24));
+		const days = this.config.type === "hourly"
+			? Math.min(14, Math.max(requestedDays, hourlyDays))
+			: this.config.type === "daily"
+				? Math.min(14, requestedDays)
+				: 1;
+
+		const params = {
+			q: `${this.config.lat},${this.config.lon}`,
+			days,
+			lang: this.config.lang,
+			key: this.config.apiKey
+		};
+
+		return Object.keys(params)
+			.filter((key) => params[key] !== undefined && params[key] !== null && `${params[key]}`.trim() !== "")
+			.map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
+			.join("&");
+	}
+
+	#getUrl () {
+		return `${this.config.apiBase}/forecast.json?${this.#getQueryParameters()}`;
+	}
+
+	#parseResponse (responseData) {
+		responseData.location ??= {};
+		responseData.current ??= {};
+		responseData.current.condition ??= {};
+		responseData.forecast ??= {};
+		responseData.forecast.forecastday ??= [];
+		responseData.forecast.forecastday = responseData.forecast.forecastday.map((forecastDay) => ({
+			...forecastDay,
+			astro: forecastDay.astro ?? {},
+			day: forecastDay.day ?? {},
+			hour: forecastDay.hour ?? []
+		}));
+
+		const locationParts = [
+			responseData.location.name,
+			responseData.location.region,
+			responseData.location.country
+		]
+			.map((value) => `${value}`.trim())
+			.filter((value) => value !== "");
+
+		if (locationParts.length > 0) {
+			this.locationName = locationParts.join(", ").trim();
+		}
+
+		if (
+			!responseData.location
+			|| !responseData.current
+			|| !responseData.forecast
+			|| !Array.isArray(responseData.forecast.forecastday)
+		) {
+			throw new Error("Invalid API response");
+		}
+
+		return responseData;
+	}
+
+	#parseSunDatetime (forecastDay, key) {
+		const timeValue = forecastDay?.astro?.[key];
+		if (!timeValue || !forecastDay?.date) {
+			return null;
+		}
+
+		const match = (/^\s*(\d{1,2}):(\d{2})\s*(AM|PM)\s*$/i).exec(timeValue);
+		if (!match) {
+			return null;
+		}
+
+		let hour = parseInt(match[1], 10);
+		const minute = parseInt(match[2], 10);
+		const period = match[3].toUpperCase();
+
+		if (period === "PM" && hour !== 12) hour += 12;
+		if (period === "AM" && hour === 12) hour = 0;
+
+		const date = new Date(`${forecastDay.date}T00:00:00`);
+		date.setHours(hour, minute, 0, 0);
+		return date;
+	}
+
+	#toNumber (value) {
+		const number = parseFloat(value);
+		return Number.isFinite(number) ? number : null;
+	}
+
+	#generateCurrent (data) {
+		const weather = data.forecast.forecastday[0] ?? {};
+		const current = data.current ?? {};
+		const currentWeather = {
+			date: current.last_updated_epoch ? new Date(current.last_updated_epoch * 1000) : new Date()
+		};
+
+		const humidity = this.#toNumber(current.humidity);
+		if (humidity !== null) currentWeather.humidity = humidity;
+
+		const temperature = this.#toNumber(current.temp_c);
+		if (temperature !== null) currentWeather.temperature = temperature;
+
+		const feelsLikeTemp = this.#toNumber(current.feelslike_c);
+		if (feelsLikeTemp !== null) currentWeather.feelsLikeTemp = feelsLikeTemp;
+
+		const windSpeed = this.#toNumber(current.wind_kph);
+		if (windSpeed !== null) currentWeather.windSpeed = convertKmhToMs(windSpeed);
+
+		const windFromDirection = this.#toNumber(current.wind_degree);
+		if (windFromDirection !== null) currentWeather.windFromDirection = windFromDirection;
+
+		if (current.condition?.code !== undefined) {
+			currentWeather.weatherType = this.#convertWeatherType(current.condition.code, current.is_day === 1);
+		}
+
+		const sunrise = this.#parseSunDatetime(weather, "sunrise");
+		const sunset = this.#parseSunDatetime(weather, "sunset");
+		if (sunrise) currentWeather.sunrise = sunrise;
+		if (sunset) currentWeather.sunset = sunset;
+
+		const minTemperature = this.#toNumber(weather.day?.mintemp_c);
+		if (minTemperature !== null) currentWeather.minTemperature = minTemperature;
+
+		const maxTemperature = this.#toNumber(weather.day?.maxtemp_c);
+		if (maxTemperature !== null) currentWeather.maxTemperature = maxTemperature;
+
+		const snow = this.#toNumber(current.snow_cm);
+		if (snow !== null) currentWeather.snow = snow * 10;
+
+		const rain = this.#toNumber(current.precip_mm);
+		if (rain !== null) currentWeather.rain = rain;
+
+		if (rain !== null || snow !== null) {
+			currentWeather.precipitationAmount = (rain ?? 0) + ((snow ?? 0) * 10);
+		}
+
+		return currentWeather;
+	}
+
+	#generateDaily (data) {
+		const days = [];
+		const forecastDays = data.forecast.forecastday ?? [];
+
+		for (const forecastDay of forecastDays) {
+			const weather = {};
+			const dayDate = forecastDay.date_epoch
+				? new Date(forecastDay.date_epoch * 1000)
+				: new Date(`${forecastDay.date}T00:00:00`);
+
+			const precipitationProbability = forecastDay.hour?.length > 0
+				? (forecastDay.hour.reduce((sum, hourData) => {
+					const rain = this.#toNumber(hourData.will_it_rain) ?? 0;
+					const snow = this.#toNumber(hourData.will_it_snow) ?? 0;
+					return sum + ((rain + snow) / 2);
+				}, 0) / forecastDay.hour.length) * 100
+				: null;
+
+			const avgWindDegree = forecastDay.hour?.length > 0
+				? forecastDay.hour.reduce((sum, hourData) => {
+					return sum + (this.#toNumber(hourData.wind_degree) ?? 0);
+				}, 0) / forecastDay.hour.length
+				: null;
+
+			weather.date = dayDate;
+			weather.minTemperature = this.#toNumber(forecastDay.day?.mintemp_c);
+			weather.maxTemperature = this.#toNumber(forecastDay.day?.maxtemp_c);
+			weather.weatherType = this.#convertWeatherType(forecastDay.day?.condition?.code, true);
+
+			const maxWind = this.#toNumber(forecastDay.day?.maxwind_kph);
+			if (maxWind !== null) weather.windSpeed = convertKmhToMs(maxWind);
+
+			if (avgWindDegree !== null) {
+				weather.windFromDirection = avgWindDegree;
+			}
+
+			const sunrise = this.#parseSunDatetime(forecastDay, "sunrise");
+			const sunset = this.#parseSunDatetime(forecastDay, "sunset");
+			if (sunrise) weather.sunrise = sunrise;
+			if (sunset) weather.sunset = sunset;
+
+			weather.temperature = this.#toNumber(forecastDay.day?.avgtemp_c);
+			weather.humidity = this.#toNumber(forecastDay.day?.avghumidity);
+
+			const snow = this.#toNumber(forecastDay.day?.totalsnow_cm);
+			if (snow !== null) weather.snow = snow * 10;
+
+			const rain = this.#toNumber(forecastDay.day?.totalprecip_mm);
+			if (rain !== null) weather.rain = rain;
+
+			if (rain !== null || snow !== null) {
+				weather.precipitationAmount = (rain ?? 0) + ((snow ?? 0) * 10);
+			}
+
+			if (precipitationProbability !== null) {
+				weather.precipitationProbability = precipitationProbability;
+			}
+
+			weather.uv_index = this.#toNumber(forecastDay.day?.uv);
+
+			days.push(weather);
+
+			if (days.length >= this.config.maxEntries) {
+				break;
+			}
+		}
+
+		return days;
+	}
+
+	#generateHourly (data) {
+		const hours = [];
+		const nowStart = new Date();
+		nowStart.setMinutes(0, 0, 0);
+		nowStart.setHours(nowStart.getHours() + 1);
+
+		for (const forecastDay of data.forecast.forecastday ?? []) {
+			for (const hourData of forecastDay.hour ?? []) {
+				const date = hourData.time_epoch
+					? new Date(hourData.time_epoch * 1000)
+					: new Date(hourData.time);
+
+				if (date < nowStart) {
+					continue;
+				}
+
+				const weather = { date };
+
+				const sunrise = this.#parseSunDatetime(forecastDay, "sunrise");
+				const sunset = this.#parseSunDatetime(forecastDay, "sunset");
+				if (sunrise) weather.sunrise = sunrise;
+				if (sunset) weather.sunset = sunset;
+
+				weather.minTemperature = this.#toNumber(forecastDay.day?.mintemp_c);
+				weather.maxTemperature = this.#toNumber(forecastDay.day?.maxtemp_c);
+				weather.humidity = this.#toNumber(hourData.humidity);
+
+				const windSpeed = this.#toNumber(hourData.wind_kph);
+				if (windSpeed !== null) weather.windSpeed = convertKmhToMs(windSpeed);
+
+				const windDegree = this.#toNumber(hourData.wind_degree);
+				weather.windFromDirection = windDegree !== null
+					? windDegree
+					: cardinalToDegrees(hourData.wind_dir);
+
+				weather.weatherType = this.#convertWeatherType(hourData.condition?.code, hourData.is_day === 1);
+
+				const snow = this.#toNumber(hourData.snow_cm);
+				if (snow !== null) weather.snow = snow * 10;
+
+				weather.temperature = this.#toNumber(hourData.temp_c);
+				weather.precipitationAmount = this.#toNumber(hourData.precip_mm);
+
+				const willRain = this.#toNumber(hourData.will_it_rain) ?? 0;
+				const willSnow = this.#toNumber(hourData.will_it_snow) ?? 0;
+				weather.precipitationProbability = (willRain + willSnow) * 50;
+
+				weather.uv_index = this.#toNumber(hourData.uv);
+
+				hours.push(weather);
+
+				if (hours.length >= this.config.maxEntries) {
+					break;
+				}
+			}
+
+			if (hours.length >= this.config.maxEntries) {
+				break;
+			}
+		}
+
+		return hours;
+	}
+
+	#convertWeatherType (weatherCode, isDayTime) {
+		const weatherConditions = {
+			1000: { day: "day-sunny", night: "night-clear" },
+			1003: { day: "day-cloudy", night: "night-alt-cloudy" },
+			1006: { day: "day-cloudy", night: "night-alt-cloudy" },
+			1009: { day: "day-sunny-overcast", night: "night-alt-partly-cloudy" },
+			1030: { day: "day-fog", night: "night-fog" },
+			1063: { day: "day-sprinkle", night: "night-sprinkle" },
+			1066: { day: "day-snow-wind", night: "night-snow-wind" },
+			1069: { day: "day-sleet", night: "night-sleet" },
+			1072: { day: "day-sprinkle", night: "night-sprinkle" },
+			1087: { day: "day-thunderstorm", night: "night-thunderstorm" },
+			1114: { day: "day-snow-wind", night: "night-snow-wind" },
+			1117: { day: "windy", night: "windy" },
+			1135: { day: "day-fog", night: "night-fog" },
+			1147: { day: "day-fog", night: "night-fog" },
+			1150: { day: "day-sprinkle", night: "night-sprinkle" },
+			1153: { day: "day-sprinkle", night: "night-sprinkle" },
+			1168: { day: "day-sprinkle", night: "night-sprinkle" },
+			1171: { day: "day-sprinkle", night: "night-sprinkle" },
+			1180: { day: "day-sprinkle", night: "night-sprinkle" },
+			1183: { day: "day-sprinkle", night: "night-sprinkle" },
+			1186: { day: "day-showers", night: "night-showers" },
+			1189: { day: "day-showers", night: "night-showers" },
+			1192: { day: "day-showers", night: "night-showers" },
+			1195: { day: "day-showers", night: "night-showers" },
+			1198: { day: "day-thunderstorm", night: "night-thunderstorm" },
+			1201: { day: "day-thunderstorm", night: "night-thunderstorm" },
+			1204: { day: "day-sprinkle", night: "night-sprinkle" },
+			1207: { day: "day-showers", night: "night-showers" },
+			1210: { day: "snowflake-cold", night: "snowflake-cold" },
+			1213: { day: "snowflake-cold", night: "snowflake-cold" },
+			1216: { day: "snowflake-cold", night: "snowflake-cold" },
+			1219: { day: "snowflake-cold", night: "snowflake-cold" },
+			1222: { day: "snowflake-cold", night: "snowflake-cold" },
+			1225: { day: "snowflake-cold", night: "snowflake-cold" },
+			1237: { day: "day-sleet", night: "night-sleet" },
+			1240: { day: "day-sprinkle", night: "night-sprinkle" },
+			1243: { day: "day-showers", night: "night-showers" },
+			1246: { day: "day-showers", night: "night-showers" },
+			1249: { day: "day-showers", night: "night-showers" },
+			1252: { day: "day-showers", night: "night-showers" },
+			1255: { day: "day-snow-wind", night: "night-snow-wind" },
+			1258: { day: "day-snow-wind", night: "night-snow-wind" },
+			1261: { day: "day-sleet", night: "night-sleet" },
+			1264: { day: "day-sleet", night: "night-sleet" },
+			1273: { day: "day-thunderstorm", night: "night-thunderstorm" },
+			1276: { day: "day-thunderstorm", night: "night-thunderstorm" },
+			1279: { day: "day-snow-thunderstorm", night: "night-snow-thunderstorm" },
+			1282: { day: "day-snow-thunderstorm", night: "night-snow-thunderstorm" }
+		};
+
+		if (!Object.prototype.hasOwnProperty.call(weatherConditions, weatherCode)) {
+			return "na";
+		}
+
+		return weatherConditions[weatherCode][isDayTime ? "day" : "night"];
+	}
+}
+
+module.exports = WeatherAPIProvider;

defaultmodules/weather/providers/weatherbit.js

@@ -0,0 +1,292 @@
+const Log = require("logger");
+const HTTPFetcher = require("#http_fetcher");
+
+/**
+ * Weatherbit weather provider
+ * See: https://www.weatherbit.io/
+ */
+class WeatherbitProvider {
+	constructor (config) {
+		this.config = {
+			apiBase: "https://api.weatherbit.io/v2.0",
+			apiKey: "",
+			lat: 0,
+			lon: 0,
+			type: "current",
+			updateInterval: 10 * 60 * 1000,
+			...config
+		};
+
+		this.fetcher = null;
+		this.onDataCallback = null;
+		this.onErrorCallback = null;
+	}
+
+	setCallbacks (onDataCallback, onErrorCallback) {
+		this.onDataCallback = onDataCallback;
+		this.onErrorCallback = onErrorCallback;
+	}
+
+	initialize () {
+		if (!this.config.apiKey || this.config.apiKey === "YOUR_API_KEY_HERE") {
+			Log.error("[weatherbit] No API key configured");
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: "Weatherbit API key required. Get one at https://www.weatherbit.io/",
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+			return;
+		}
+
+		this.#initializeFetcher();
+	}
+
+	#initializeFetcher () {
+		const url = this.#getUrl();
+
+		this.fetcher = new HTTPFetcher(url, {
+			reloadInterval: this.config.updateInterval,
+			headers: {
+				Accept: "application/json"
+			},
+			logContext: "weatherprovider.weatherbit"
+		});
+
+		this.fetcher.on("response", async (response) => {
+			try {
+				const data = await response.json();
+				this.#handleResponse(data);
+			} catch (error) {
+				Log.error("[weatherbit] Parse error:", error);
+				if (this.onErrorCallback) {
+					this.onErrorCallback({
+						message: "Failed to parse API response",
+						translationKey: "MODULE_ERROR_UNSPECIFIED"
+					});
+				}
+			}
+		});
+
+		this.fetcher.on("error", (errorInfo) => {
+			if (this.onErrorCallback) {
+				this.onErrorCallback(errorInfo);
+			}
+		});
+	}
+
+	#getUrl () {
+		const endpoint = this.#getWeatherEndpoint();
+		return `${this.config.apiBase}${endpoint}?lat=${this.config.lat}&lon=${this.config.lon}&units=M&key=${this.config.apiKey}`;
+	}
+
+	#getWeatherEndpoint () {
+		switch (this.config.type) {
+			case "hourly":
+				return "/forecast/hourly";
+			case "daily":
+			case "forecast":
+				return "/forecast/daily";
+			case "current":
+			default:
+				return "/current";
+		}
+	}
+
+	#handleResponse (data) {
+		if (!data || !data.data || data.data.length === 0) {
+			Log.error("[weatherbit] No usable data received");
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: "No usable data in API response",
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+			return;
+		}
+
+		let weatherData = null;
+
+		switch (this.config.type) {
+			case "current":
+				weatherData = this.#generateCurrent(data);
+				break;
+			case "forecast":
+			case "daily":
+				weatherData = this.#generateDaily(data);
+				break;
+			case "hourly":
+				weatherData = this.#generateHourly(data);
+				break;
+			default:
+				Log.error(`[weatherbit] Unknown weather type: ${this.config.type}`);
+				break;
+		}
+
+		if (weatherData && this.onDataCallback) {
+			this.onDataCallback(weatherData);
+		}
+	}
+
+	#generateCurrent (data) {
+		if (!data.data[0] || typeof data.data[0].temp === "undefined") {
+			return null;
+		}
+
+		const current = data.data[0];
+
+		const weather = {
+			date: new Date(current.ts * 1000),
+			temperature: parseFloat(current.temp),
+			humidity: parseFloat(current.rh),
+			windSpeed: parseFloat(current.wind_spd),
+			windFromDirection: current.wind_dir || null,
+			weatherType: this.#convertWeatherType(current.weather.icon),
+			sunrise: null,
+			sunset: null
+		};
+
+		// Parse sunrise/sunset from HH:mm format (already in local time)
+		if (current.sunrise) {
+			const [hours, minutes] = current.sunrise.split(":");
+			const sunrise = new Date(current.ts * 1000);
+			sunrise.setHours(parseInt(hours), parseInt(minutes), 0, 0);
+			weather.sunrise = sunrise;
+		}
+
+		if (current.sunset) {
+			const [hours, minutes] = current.sunset.split(":");
+			const sunset = new Date(current.ts * 1000);
+			sunset.setHours(parseInt(hours), parseInt(minutes), 0, 0);
+			weather.sunset = sunset;
+		}
+
+		return weather;
+	}
+
+	#generateDaily (data) {
+		const days = [];
+
+		for (const forecast of data.data) {
+			days.push({
+				date: new Date(forecast.datetime),
+				minTemperature: forecast.min_temp !== undefined ? parseFloat(forecast.min_temp) : null,
+				maxTemperature: forecast.max_temp !== undefined ? parseFloat(forecast.max_temp) : null,
+				precipitationAmount: forecast.precip !== undefined ? parseFloat(forecast.precip) : 0,
+				precipitationProbability: forecast.pop !== undefined ? parseFloat(forecast.pop) : null,
+				weatherType: this.#convertWeatherType(forecast.weather.icon)
+			});
+		}
+
+		return days;
+	}
+
+	#generateHourly (data) {
+		const hours = [];
+
+		for (const forecast of data.data) {
+			hours.push({
+				date: new Date(forecast.timestamp_local),
+				temperature: forecast.temp !== undefined ? parseFloat(forecast.temp) : null,
+				precipitationAmount: forecast.precip !== undefined ? parseFloat(forecast.precip) : 0,
+				precipitationProbability: forecast.pop !== undefined ? parseFloat(forecast.pop) : null,
+				windSpeed: forecast.wind_spd !== undefined ? parseFloat(forecast.wind_spd) : null,
+				windFromDirection: forecast.wind_dir || null,
+				weatherType: this.#convertWeatherType(forecast.weather.icon)
+			});
+		}
+
+		return hours;
+	}
+
+	/**
+	 * Convert Weatherbit icon codes to weathericons.css icons
+	 * See: https://www.weatherbit.io/api/codes
+	 * @param {string} weatherType - Weatherbit icon code
+	 * @returns {string|null} Weathericons.css icon name or null
+	 */
+	#convertWeatherType (weatherType) {
+		const weatherTypes = {
+			t01d: "day-thunderstorm",
+			t01n: "night-alt-thunderstorm",
+			t02d: "day-thunderstorm",
+			t02n: "night-alt-thunderstorm",
+			t03d: "thunderstorm",
+			t03n: "thunderstorm",
+			t04d: "day-thunderstorm",
+			t04n: "night-alt-thunderstorm",
+			t05d: "day-sleet-storm",
+			t05n: "night-alt-sleet-storm",
+			d01d: "day-sprinkle",
+			d01n: "night-alt-sprinkle",
+			d02d: "day-sprinkle",
+			d02n: "night-alt-sprinkle",
+			d03d: "day-showers",
+			d03n: "night-alt-showers",
+			r01d: "day-showers",
+			r01n: "night-alt-showers",
+			r02d: "day-rain",
+			r02n: "night-alt-rain",
+			r03d: "day-rain",
+			r03n: "night-alt-rain",
+			r04d: "day-sprinkle",
+			r04n: "night-alt-sprinkle",
+			r05d: "day-showers",
+			r05n: "night-alt-showers",
+			r06d: "day-showers",
+			r06n: "night-alt-showers",
+			f01d: "day-sleet",
+			f01n: "night-alt-sleet",
+			s01d: "day-snow",
+			s01n: "night-alt-snow",
+			s02d: "day-snow-wind",
+			s02n: "night-alt-snow-wind",
+			s03d: "snowflake-cold",
+			s03n: "snowflake-cold",
+			s04d: "day-rain-mix",
+			s04n: "night-alt-rain-mix",
+			s05d: "day-sleet",
+			s05n: "night-alt-sleet",
+			s06d: "day-snow",
+			s06n: "night-alt-snow",
+			a01d: "day-haze",
+			a01n: "dust",
+			a02d: "smoke",
+			a02n: "smoke",
+			a03d: "day-haze",
+			a03n: "dust",
+			a04d: "dust",
+			a04n: "dust",
+			a05d: "day-fog",
+			a05n: "night-fog",
+			a06d: "fog",
+			a06n: "fog",
+			c01d: "day-sunny",
+			c01n: "night-clear",
+			c02d: "day-sunny-overcast",
+			c02n: "night-alt-partly-cloudy",
+			c03d: "day-cloudy",
+			c03n: "night-alt-cloudy",
+			c04d: "cloudy",
+			c04n: "cloudy",
+			u00d: "rain-mix",
+			u00n: "rain-mix"
+		};
+
+		return weatherTypes[weatherType] || null;
+	}
+
+	start () {
+		if (this.fetcher) {
+			this.fetcher.startPeriodicFetch();
+		}
+	}
+
+	stop () {
+		if (this.fetcher) {
+			this.fetcher.clearTimer();
+		}
+	}
+}
+
+module.exports = WeatherbitProvider;

defaultmodules/weather/providers/weatherflow.js

@@ -0,0 +1,298 @@
+const Log = require("logger");
+const { convertKmhToMs } = require("../provider-utils");
+const HTTPFetcher = require("#http_fetcher");
+
+/**
+ * WeatherFlow weather provider
+ * This class is a provider for WeatherFlow personal weather stations.
+ * Note that the WeatherFlow API does not provide snowfall.
+ */
+class WeatherFlowProvider {
+
+	/**
+	 * @param {object} config - Provider configuration
+	 */
+	constructor (config) {
+		this.config = config;
+		this.fetcher = null;
+		this.onDataCallback = null;
+		this.onErrorCallback = null;
+	}
+
+	/**
+	 * Set the callbacks for data and errors
+	 * @param {(data: object) => void} onDataCallback - Called when new data is available
+	 * @param {(error: object) => void} onErrorCallback - Called when an error occurs
+	 */
+	setCallbacks (onDataCallback, onErrorCallback) {
+		this.onDataCallback = onDataCallback;
+		this.onErrorCallback = onErrorCallback;
+	}
+
+	/**
+	 * Initialize the provider
+	 */
+	initialize () {
+		if (!this.config.token || this.config.token === "YOUR_API_TOKEN_HERE") {
+			Log.error("[weatherflow] No API token configured. Get one at https://tempestwx.com/");
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: "WeatherFlow API token required. Get one at https://tempestwx.com/",
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+			return;
+		}
+
+		if (!this.config.stationid) {
+			Log.error("[weatherflow] No station ID configured");
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: "WeatherFlow station ID required",
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+			return;
+		}
+
+		this.#initializeFetcher();
+	}
+
+	/**
+	 * Initialize the HTTP fetcher
+	 */
+	#initializeFetcher () {
+		const url = this.#getUrl();
+
+		this.fetcher = new HTTPFetcher(url, {
+			reloadInterval: this.config.updateInterval,
+			headers: {
+				"Cache-Control": "no-cache",
+				Accept: "application/json"
+			},
+			logContext: "weatherprovider.weatherflow"
+		});
+
+		this.fetcher.on("response", async (response) => {
+			try {
+				const data = await response.json();
+				const processed = this.#processData(data);
+				this.onDataCallback(processed);
+			} catch (error) {
+				Log.error("[weatherflow] Failed to parse JSON:", error);
+			}
+		});
+
+		this.fetcher.on("error", (errorInfo) => {
+			// HTTPFetcher already logged the error with logContext
+			if (this.onErrorCallback) {
+				this.onErrorCallback(errorInfo);
+			}
+		});
+	}
+
+	/**
+	 * Generate the URL for API requests
+	 * @returns {string} The API URL
+	 */
+	#getUrl () {
+		const base = this.config.apiBase || "https://swd.weatherflow.com/swd/rest/";
+		return `${base}better_forecast?station_id=${this.config.stationid}&units_temp=c&units_wind=kph&units_pressure=mb&units_precip=mm&units_distance=km&token=${this.config.token}`;
+	}
+
+	/**
+	 * Process the raw API data
+	 * @param {object} data - Raw API response
+	 * @returns {object} Processed weather data
+	 */
+	#processData (data) {
+		try {
+			let weatherData;
+			if (this.config.type === "current") {
+				weatherData = this.#generateCurrent(data);
+			} else if (this.config.type === "hourly") {
+				weatherData = this.#generateHourly(data);
+			} else {
+				weatherData = this.#generateDaily(data);
+			}
+
+			return weatherData;
+		} catch (error) {
+			Log.error("[weatherflow] Data processing error:", error);
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: "Failed to process weather data",
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+			return null;
+		}
+	}
+
+	/**
+	 * Generate current weather data
+	 * @param {object} data - API response data
+	 * @returns {object} Current weather object
+	 */
+	#generateCurrent (data) {
+		if (!data || !data.current_conditions || !data.forecast || !Array.isArray(data.forecast.daily) || data.forecast.daily.length === 0) {
+			Log.error("[weatherflow] Invalid current weather data structure");
+			return null;
+		}
+
+		const current = data.current_conditions;
+		const daily = data.forecast.daily[0];
+
+		const weather = {
+			date: new Date(),
+			humidity: current.relative_humidity || null,
+			temperature: current.air_temperature || null,
+			feelsLikeTemp: current.feels_like || null,
+			windSpeed: current.wind_avg != null ? convertKmhToMs(current.wind_avg) : null,
+			windFromDirection: current.wind_direction || null,
+			weatherType: this.#convertWeatherType(current.icon),
+			uvIndex: current.uv || null,
+			sunrise: daily.sunrise ? new Date(daily.sunrise * 1000) : null,
+			sunset: daily.sunset ? new Date(daily.sunset * 1000) : null
+		};
+
+		return weather;
+	}
+
+	/**
+	 * Generate forecast data
+	 * @param {object} data - API response data
+	 * @returns {Array} Array of forecast objects
+	 */
+	#generateDaily (data) {
+		if (!data || !data.forecast || !Array.isArray(data.forecast.daily) || !Array.isArray(data.forecast.hourly)) {
+			Log.error("[weatherflow] Invalid forecast data structure");
+			return [];
+		}
+
+		const days = [];
+
+		for (const forecast of data.forecast.daily) {
+			const weather = {
+				date: new Date(forecast.day_start_local * 1000),
+				minTemperature: forecast.air_temp_low || null,
+				maxTemperature: forecast.air_temp_high || null,
+				precipitationProbability: forecast.precip_probability || null,
+				weatherType: this.#convertWeatherType(forecast.icon),
+				precipitationAmount: 0.0,
+				precipitationUnits: "mm",
+				uvIndex: 0
+			};
+
+			// Build UV and precipitation from hourly data
+			for (const hour of data.forecast.hourly) {
+				const hourDate = new Date(hour.time * 1000);
+				const forecastDate = new Date(forecast.day_start_local * 1000);
+
+				// Compare year, month, and day to ensure correct matching across month boundaries
+				if (hourDate.getFullYear() === forecastDate.getFullYear()
+				  && hourDate.getMonth() === forecastDate.getMonth()
+				  && hourDate.getDate() === forecastDate.getDate()) {
+					weather.uvIndex = Math.max(weather.uvIndex, hour.uv || 0);
+					weather.precipitationAmount += hour.precip || 0;
+				} else if (hourDate > forecastDate) {
+					// Check if we've moved to the next day
+					const diffMs = hourDate - forecastDate;
+					if (diffMs >= 86400000) break; // 24 hours in ms
+				}
+			}
+
+			days.push(weather);
+		}
+
+		return days;
+	}
+
+	/**
+	 * Generate hourly forecast data
+	 * @param {object} data - API response data
+	 * @returns {Array} Array of hourly forecast objects
+	 */
+	#generateHourly (data) {
+		if (!data || !data.forecast || !Array.isArray(data.forecast.hourly)) {
+			Log.error("[weatherflow] Invalid hourly data structure");
+			return [];
+		}
+
+		const hours = [];
+
+		for (const hour of data.forecast.hourly) {
+			const weather = {
+				date: new Date(hour.time * 1000),
+				temperature: hour.air_temperature || null,
+				feelsLikeTemp: hour.feels_like || null,
+				humidity: hour.relative_humidity || null,
+				windSpeed: hour.wind_avg != null ? convertKmhToMs(hour.wind_avg) : null,
+				windFromDirection: hour.wind_direction || null,
+				weatherType: this.#convertWeatherType(hour.icon),
+				precipitationProbability: hour.precip_probability || null,
+				precipitationAmount: hour.precip || 0,
+				precipitationUnits: "mm",
+				uvIndex: hour.uv || null
+			};
+
+			hours.push(weather);
+
+			// WeatherFlow provides 10 days of hourly data, trim to 48 hours
+			if (hours.length >= 48) break;
+		}
+
+		return hours;
+	}
+
+	/**
+	 * Convert weather icon type
+	 * @param {string} weatherType - WeatherFlow icon code
+	 * @returns {string} Weather icon CSS class
+	 */
+	#convertWeatherType (weatherType) {
+		const weatherTypes = {
+			"clear-day": "day-sunny",
+			"clear-night": "night-clear",
+			cloudy: "cloudy",
+			foggy: "fog",
+			"partly-cloudy-day": "day-cloudy",
+			"partly-cloudy-night": "night-alt-cloudy",
+			"possibly-rainy-day": "day-rain",
+			"possibly-rainy-night": "night-alt-rain",
+			"possibly-sleet-day": "day-sleet",
+			"possibly-sleet-night": "night-alt-sleet",
+			"possibly-snow-day": "day-snow",
+			"possibly-snow-night": "night-alt-snow",
+			"possibly-thunderstorm-day": "day-thunderstorm",
+			"possibly-thunderstorm-night": "night-alt-thunderstorm",
+			rainy: "rain",
+			sleet: "sleet",
+			snow: "snow",
+			thunderstorm: "thunderstorm",
+			windy: "strong-wind"
+		};
+
+		return weatherTypes[weatherType] || null;
+	}
+
+	/**
+	 * Start fetching data
+	 */
+	start () {
+		if (this.fetcher) {
+			this.fetcher.startPeriodicFetch();
+		}
+	}
+
+	/**
+	 * Stop fetching data
+	 */
+	stop () {
+		if (this.fetcher) {
+			this.fetcher.clearTimer();
+		}
+	}
+}
+
+module.exports = WeatherFlowProvider;

defaultmodules/weather/providers/weathergov.js

@@ -0,0 +1,416 @@
+const Log = require("logger");
+const { getSunTimes, isDayTime, getDateString, convertKmhToMs, cardinalToDegrees } = require("../provider-utils");
+const HTTPFetcher = require("#http_fetcher");
+
+/**
+ * Server-side weather provider for Weather.gov (US National Weather Service)
+ * Note: Only works for US locations, no API key required
+ * https://weather-gov.github.io/api/general-faqs
+ */
+class WeatherGovProvider {
+	constructor (config) {
+		this.config = {
+			apiBase: "https://api.weather.gov/points/",
+			lat: 0,
+			lon: 0,
+			type: "current",
+			updateInterval: 10 * 60 * 1000,
+			...config
+		};
+
+		this.fetcher = null;
+		this.onDataCallback = null;
+		this.onErrorCallback = null;
+		this.locationName = null;
+		this.initRetryCount = 0;
+		this.initRetryTimer = null;
+
+		// Weather.gov specific URLs (fetched during initialization)
+		this.forecastURL = null;
+		this.forecastHourlyURL = null;
+		this.forecastGridDataURL = null;
+		this.observationStationsURL = null;
+		this.stationObsURL = null;
+	}
+
+	async initialize () {
+		// Add small random delay to prevent all instances from starting simultaneously
+		// This reduces parallel DNS lookups which can cause EAI_AGAIN errors
+		const staggerDelay = Math.random() * 3000; // 0-3 seconds
+		await new Promise((resolve) => setTimeout(resolve, staggerDelay));
+
+		try {
+			await this.#fetchWeatherGovURLs();
+			this.#initializeFetcher();
+			this.initRetryCount = 0; // Reset on success
+		} catch (error) {
+			const errorInfo = this.#categorizeError(error);
+			Log.error(`[weathergov] Initialization failed: ${errorInfo.message}`);
+
+			// Retry on temporary errors (DNS, timeout, network)
+			if (errorInfo.isRetryable && this.initRetryCount < 5) {
+				this.initRetryCount++;
+				const delay = HTTPFetcher.calculateBackoffDelay(this.initRetryCount);
+				Log.info(`[weathergov] Will retry initialization in ${Math.round(delay / 1000)}s (attempt ${this.initRetryCount}/5)`);
+				this.initRetryTimer = setTimeout(() => this.initialize(), delay);
+			} else if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: errorInfo.message,
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+		}
+	}
+
+	#categorizeError (error) {
+		const cause = error.cause || error;
+		const code = cause.code || "";
+
+		if (code === "EAI_AGAIN" || code === "ENOTFOUND") {
+			return {
+				message: "DNS lookup failed for api.weather.gov - check your internet connection",
+				isRetryable: true
+			};
+		}
+		if (code === "ETIMEDOUT" || code === "ECONNREFUSED" || code === "ECONNRESET") {
+			return {
+				message: `Network error: ${code} - api.weather.gov may be temporarily unavailable`,
+				isRetryable: true
+			};
+		}
+		if (error.name === "AbortError") {
+			return {
+				message: "Request timeout - api.weather.gov is responding slowly",
+				isRetryable: true
+			};
+		}
+
+		return {
+			message: error.message || "Unknown error",
+			isRetryable: false
+		};
+	}
+
+	setCallbacks (onData, onError) {
+		this.onDataCallback = onData;
+		this.onErrorCallback = onError;
+	}
+
+	start () {
+		if (this.fetcher) {
+			this.fetcher.startPeriodicFetch();
+		}
+	}
+
+	stop () {
+		if (this.fetcher) {
+			this.fetcher.clearTimer();
+		}
+		if (this.initRetryTimer) {
+			clearTimeout(this.initRetryTimer);
+			this.initRetryTimer = null;
+		}
+	}
+
+	async #fetchWeatherGovURLs () {
+		// Step 1: Get grid point data
+		const pointsUrl = `${this.config.apiBase}${this.config.lat},${this.config.lon}`;
+
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 120000); // 120 second timeout - DNS can be slow
+
+		try {
+			const pointsResponse = await fetch(pointsUrl, {
+				signal: controller.signal,
+				headers: {
+					"User-Agent": "MagicMirror",
+					Accept: "application/geo+json"
+				}
+			});
+
+			if (!pointsResponse.ok) {
+				throw new Error(`Failed to fetch grid point: HTTP ${pointsResponse.status}`);
+			}
+
+			const pointsData = await pointsResponse.json();
+
+			if (!pointsData || !pointsData.properties) {
+				throw new Error("Invalid grid point data");
+			}
+
+			// Extract location name
+			const relLoc = pointsData.properties.relativeLocation?.properties;
+			if (relLoc) {
+				this.locationName = `${relLoc.city}, ${relLoc.state}`;
+			}
+
+			// Store forecast URLs
+			this.forecastURL = `${pointsData.properties.forecast}?units=si`;
+			this.forecastHourlyURL = `${pointsData.properties.forecastHourly}?units=si`;
+			this.forecastGridDataURL = pointsData.properties.forecastGridData;
+			this.observationStationsURL = pointsData.properties.observationStations;
+
+			// Step 2: Get observation station URL
+			const stationsResponse = await fetch(this.observationStationsURL, {
+				signal: controller.signal,
+				headers: {
+					"User-Agent": "MagicMirror",
+					Accept: "application/geo+json"
+				}
+			});
+
+			if (!stationsResponse.ok) {
+				throw new Error(`Failed to fetch observation stations: HTTP ${stationsResponse.status}`);
+			}
+
+			const stationsData = await stationsResponse.json();
+
+			if (!stationsData || !stationsData.features || stationsData.features.length === 0) {
+				throw new Error("No observation stations found");
+			}
+
+			this.stationObsURL = `${stationsData.features[0].id}/observations/latest`;
+
+			Log.log(`[weathergov] Initialized for ${this.locationName}`);
+		} finally {
+			clearTimeout(timeoutId);
+		}
+	}
+
+	#initializeFetcher () {
+		let url;
+
+		switch (this.config.type) {
+			case "current":
+				url = this.stationObsURL;
+				break;
+			case "forecast":
+			case "daily":
+				url = this.forecastURL;
+				break;
+			case "hourly":
+				url = this.forecastHourlyURL;
+				break;
+			default:
+				url = this.stationObsURL;
+		}
+
+		this.fetcher = new HTTPFetcher(url, {
+			reloadInterval: this.config.updateInterval,
+			timeout: 60000, // 60 seconds - weather.gov can be slow
+			headers: {
+				"User-Agent": "MagicMirror",
+				Accept: "application/geo+json",
+				"Cache-Control": "no-cache"
+			},
+			logContext: "weatherprovider.weathergov"
+		});
+
+		this.fetcher.on("response", async (response) => {
+			try {
+				const data = await response.json();
+				this.#handleResponse(data);
+			} catch (error) {
+				Log.error("[weathergov] Failed to parse JSON:", error);
+				if (this.onErrorCallback) {
+					this.onErrorCallback({
+						message: "Failed to parse API response",
+						translationKey: "MODULE_ERROR_UNSPECIFIED"
+					});
+				}
+			}
+		});
+
+		this.fetcher.on("error", (errorInfo) => {
+			if (this.onErrorCallback) {
+				this.onErrorCallback(errorInfo);
+			}
+		});
+	}
+
+	#handleResponse (data) {
+		try {
+			let weatherData;
+
+			switch (this.config.type) {
+				case "current":
+					if (!data.properties) {
+						throw new Error("Invalid current weather data");
+					}
+					weatherData = this.#generateWeatherObjectFromCurrentWeather(data.properties);
+					break;
+				case "forecast":
+				case "daily":
+					if (!data.properties || !data.properties.periods) {
+						throw new Error("Invalid forecast data");
+					}
+					weatherData = this.#generateWeatherObjectsFromForecast(data.properties.periods);
+					break;
+				case "hourly":
+					if (!data.properties || !data.properties.periods) {
+						throw new Error("Invalid hourly data");
+					}
+					weatherData = this.#generateWeatherObjectsFromHourly(data.properties.periods);
+					break;
+				default:
+					throw new Error(`Unknown weather type: ${this.config.type}`);
+			}
+
+			if (this.onDataCallback) {
+				this.onDataCallback(weatherData);
+			}
+		} catch (error) {
+			Log.error("[weathergov] Error processing weather data:", error);
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: error.message,
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+		}
+	}
+
+	#generateWeatherObjectFromCurrentWeather (currentWeatherData) {
+		const current = {};
+
+		current.date = new Date(currentWeatherData.timestamp);
+		current.temperature = currentWeatherData.temperature.value;
+		current.windSpeed = currentWeatherData.windSpeed.value; // Observations are already in m/s
+		current.windFromDirection = currentWeatherData.windDirection.value;
+		current.minTemperature = currentWeatherData.minTemperatureLast24Hours?.value;
+		current.maxTemperature = currentWeatherData.maxTemperatureLast24Hours?.value;
+		current.humidity = Math.round(currentWeatherData.relativeHumidity.value);
+		current.precipitationAmount = currentWeatherData.precipitationLastHour?.value ?? currentWeatherData.precipitationLast3Hours?.value;
+
+		// Feels like temperature
+		if (currentWeatherData.heatIndex.value !== null) {
+			current.feelsLikeTemp = currentWeatherData.heatIndex.value;
+		} else if (currentWeatherData.windChill.value !== null) {
+			current.feelsLikeTemp = currentWeatherData.windChill.value;
+		} else {
+			current.feelsLikeTemp = currentWeatherData.temperature.value;
+		}
+
+		// Calculate sunrise/sunset (not provided by weather.gov)
+		const { sunrise, sunset } = getSunTimes(current.date, this.config.lat, this.config.lon);
+		current.sunrise = sunrise;
+		current.sunset = sunset;
+
+		// Determine if daytime
+		const isDay = isDayTime(current.date, current.sunrise, current.sunset);
+		current.weatherType = this.#convertWeatherType(currentWeatherData.textDescription, isDay);
+
+		return current;
+	}
+
+	#generateWeatherObjectsFromForecast (forecasts) {
+		const days = [];
+		let minTemp = [];
+		let maxTemp = [];
+		let date = "";
+		let weather = {};
+
+		for (const forecast of forecasts) {
+			const forecastDate = new Date(forecast.startTime);
+			const dateStr = getDateString(forecastDate);
+
+			if (date !== dateStr) {
+				// New day
+				if (date !== "") {
+					weather.minTemperature = Math.min(...minTemp);
+					weather.maxTemperature = Math.max(...maxTemp);
+					days.push(weather);
+				}
+
+				weather = {};
+				minTemp = [];
+				maxTemp = [];
+				date = dateStr;
+
+				weather.date = forecastDate;
+				weather.precipitationProbability = forecast.probabilityOfPrecipitation?.value ?? 0;
+				weather.weatherType = this.#convertWeatherType(forecast.shortForecast, forecast.isDaytime);
+			}
+
+			// Update weather type for daytime hours (8am-5pm)
+			const hour = forecastDate.getHours();
+			if (hour >= 8 && hour <= 17) {
+				weather.weatherType = this.#convertWeatherType(forecast.shortForecast, forecast.isDaytime);
+			}
+
+			minTemp.push(forecast.temperature);
+			maxTemp.push(forecast.temperature);
+		}
+
+		// Last day
+		if (date !== "") {
+			weather.minTemperature = Math.min(...minTemp);
+			weather.maxTemperature = Math.max(...maxTemp);
+			days.push(weather);
+		}
+
+		return days.slice(1); // Skip first incomplete day
+	}
+
+	#generateWeatherObjectsFromHourly (forecasts) {
+		const hours = [];
+
+		for (const forecast of forecasts) {
+			const weather = {};
+
+			weather.date = new Date(forecast.startTime);
+
+			// Parse wind speed
+			const windSpeedStr = forecast.windSpeed;
+			let windSpeed = windSpeedStr;
+			if (windSpeedStr.includes(" ")) {
+				windSpeed = windSpeedStr.split(" ")[0];
+			}
+			weather.windSpeed = convertKmhToMs(parseFloat(windSpeed));
+			weather.windFromDirection = cardinalToDegrees(forecast.windDirection);
+			weather.temperature = forecast.temperature;
+			weather.precipitationProbability = forecast.probabilityOfPrecipitation?.value ?? 0;
+			weather.weatherType = this.#convertWeatherType(forecast.shortForecast, forecast.isDaytime);
+
+			hours.push(weather);
+		}
+
+		return hours;
+	}
+
+	#convertWeatherType (weatherType, isDaytime) {
+		// https://w1.weather.gov/xml/current_obs/weather.php
+
+		if (weatherType.includes("Cloudy") || weatherType.includes("Partly")) {
+			return isDaytime ? "day-cloudy" : "night-cloudy";
+		} else if (weatherType.includes("Overcast")) {
+			return isDaytime ? "cloudy" : "night-cloudy";
+		} else if (weatherType.includes("Freezing") || weatherType.includes("Ice")) {
+			return "rain-mix";
+		} else if (weatherType.includes("Snow")) {
+			return isDaytime ? "snow" : "night-snow";
+		} else if (weatherType.includes("Thunderstorm")) {
+			return isDaytime ? "thunderstorm" : "night-thunderstorm";
+		} else if (weatherType.includes("Showers")) {
+			return isDaytime ? "showers" : "night-showers";
+		} else if (weatherType.includes("Rain") || weatherType.includes("Drizzle")) {
+			return isDaytime ? "rain" : "night-rain";
+		} else if (weatherType.includes("Breezy") || weatherType.includes("Windy")) {
+			return isDaytime ? "cloudy-windy" : "night-alt-cloudy-windy";
+		} else if (weatherType.includes("Fair") || weatherType.includes("Clear") || weatherType.includes("Few") || weatherType.includes("Sunny")) {
+			return isDaytime ? "day-sunny" : "night-clear";
+		} else if (weatherType.includes("Dust") || weatherType.includes("Sand")) {
+			return "dust";
+		} else if (weatherType.includes("Fog")) {
+			return "fog";
+		} else if (weatherType.includes("Smoke")) {
+			return "smoke";
+		} else if (weatherType.includes("Haze")) {
+			return "day-haze";
+		}
+
+		return null;
+	}
+}
+
+module.exports = WeatherGovProvider;

defaultmodules/weather/providers/yr.js

@@ -0,0 +1,469 @@
+const Log = require("logger");
+const { formatTimezoneOffset, getDateString, validateCoordinates } = require("../provider-utils");
+const HTTPFetcher = require("#http_fetcher");
+
+/**
+ * Server-side weather provider for Yr.no (Norwegian Meteorological Institute)
+ * Terms of service: https://developer.yr.no/doc/TermsOfService/
+ *
+ * Note: Minimum update interval is 10 minutes (600000 ms) per API terms
+ */
+class YrProvider {
+	constructor (config) {
+		this.config = {
+			apiBase: "https://api.met.no/weatherapi",
+			forecastApiVersion: "2.0",
+			sunriseApiVersion: "3.0",
+			altitude: 0,
+			lat: 0,
+			lon: 0,
+			currentForecastHours: 1, // 1, 6 or 12
+			type: "current",
+			updateInterval: 10 * 60 * 1000, // 10 minutes minimum
+			...config
+		};
+
+		// Enforce 10 minute minimum per API terms
+		if (this.config.updateInterval < 600000) {
+			Log.warn("[yr] Minimum update interval is 10 minutes (600000 ms). Adjusting configuration.");
+			this.config.updateInterval = 600000;
+		}
+
+		this.fetcher = null;
+		this.onDataCallback = null;
+		this.onErrorCallback = null;
+		this.locationName = null;
+
+		// Cache for sunrise/sunset data
+		this.stellarData = null;
+		this.stellarDataDate = null;
+
+		// Cache for weather data (If-Modified-Since support)
+		this.weatherCache = {
+			data: null,
+			lastModified: null,
+			expires: null
+		};
+	}
+
+	async initialize () {
+		// Yr.no requires max 4 decimal places
+		validateCoordinates(this.config, 4);
+		await this.#fetchStellarData();
+		this.#initializeFetcher();
+	}
+
+	setCallbacks (onData, onError) {
+		this.onDataCallback = onData;
+		this.onErrorCallback = onError;
+	}
+
+	start () {
+		if (this.fetcher) {
+			this.fetcher.startPeriodicFetch();
+		}
+	}
+
+	stop () {
+		if (this.fetcher) {
+			this.fetcher.clearTimer();
+		}
+	}
+
+	async #fetchStellarData () {
+		const today = getDateString(new Date());
+
+		// Check if we already have today's data
+		if (this.stellarDataDate === today && this.stellarData) {
+			return;
+		}
+
+		const url = this.#getSunriseUrl();
+
+		try {
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), 10000);
+
+			const response = await fetch(url, {
+				headers: {
+					"User-Agent": "MagicMirror",
+					Accept: "application/json"
+				},
+				signal: controller.signal
+			});
+
+			clearTimeout(timeoutId);
+
+			if (!response.ok) {
+				Log.warn(`[yr] Could not fetch stellar data: HTTP ${response.status}`);
+				this.stellarDataDate = today;
+			} else {
+				// Parse and store the stellar data
+				const data = await response.json();
+				// Transform single-day response into array format expected by #getStellarInfoForDate
+				if (data && data.properties) {
+					this.stellarData = [
+						{
+							date: data.when.interval[0], // ISO date string
+							sunrise: data.properties.sunrise,
+							sunset: data.properties.sunset
+						}
+					];
+				}
+				this.stellarDataDate = today;
+			}
+		} catch (error) {
+			Log.warn("[yr] Failed to fetch stellar data:", error);
+		}
+	}
+
+	#initializeFetcher () {
+		const url = this.#getForecastUrl();
+
+		const headers = {
+			"User-Agent": "MagicMirror",
+			Accept: "application/json"
+		};
+
+		// Add If-Modified-Since header if we have cached data
+		if (this.weatherCache.lastModified) {
+			headers["If-Modified-Since"] = this.weatherCache.lastModified;
+		}
+
+		this.fetcher = new HTTPFetcher(url, {
+			reloadInterval: this.config.updateInterval,
+			headers,
+			logContext: "weatherprovider.yr"
+		});
+
+		this.fetcher.on("response", async (response) => {
+			try {
+				// Handle 304 Not Modified - use cached data
+				if (response.status === 304) {
+					Log.log("[yr] Data not modified, using cache");
+					if (this.weatherCache.data) {
+						this.#handleResponse(this.weatherCache.data, true);
+					}
+					return;
+				}
+
+				const data = await response.json();
+
+				// Store cache headers
+				const lastModified = response.headers.get("Last-Modified");
+				const expires = response.headers.get("Expires");
+
+				if (lastModified) {
+					this.weatherCache.lastModified = lastModified;
+				}
+				if (expires) {
+					this.weatherCache.expires = expires;
+				}
+				this.weatherCache.data = data;
+
+				// Update headers for next request
+				if (lastModified && this.fetcher) {
+					this.fetcher.customHeaders["If-Modified-Since"] = lastModified;
+				}
+
+				this.#handleResponse(data, false);
+			} catch (error) {
+				Log.error("[yr] Failed to parse JSON:", error);
+				if (this.onErrorCallback) {
+					this.onErrorCallback({
+						message: "Failed to parse API response",
+						translationKey: "MODULE_ERROR_UNSPECIFIED"
+					});
+				}
+			}
+		});
+
+		this.fetcher.on("error", (errorInfo) => {
+			if (this.onErrorCallback) {
+				this.onErrorCallback(errorInfo);
+			}
+		});
+	}
+
+	async #handleResponse (data, fromCache = false) {
+		try {
+			if (!data.properties || !data.properties.timeseries) {
+				throw new Error("Invalid weather data");
+			}
+
+			// Refresh stellar data if needed (new day or using cached weather data)
+			if (fromCache) {
+				await this.#fetchStellarData();
+			}
+
+			let weatherData;
+
+			switch (this.config.type) {
+				case "current":
+					weatherData = this.#generateCurrentWeather(data);
+					break;
+				case "forecast":
+				case "daily":
+					weatherData = this.#generateForecast(data);
+					break;
+				case "hourly":
+					weatherData = this.#generateHourly(data);
+					break;
+				default:
+					throw new Error(`Unknown weather type: ${this.config.type}`);
+			}
+
+			if (this.onDataCallback) {
+				this.onDataCallback(weatherData);
+			}
+		} catch (error) {
+			Log.error("[yr] Error processing weather data:", error);
+			if (this.onErrorCallback) {
+				this.onErrorCallback({
+					message: error.message,
+					translationKey: "MODULE_ERROR_UNSPECIFIED"
+				});
+			}
+		}
+	}
+
+	#generateCurrentWeather (data) {
+		const now = new Date();
+		const timeseries = data.properties.timeseries;
+
+		// Find closest forecast in the past
+		let forecast = timeseries[0];
+		let closestDiff = Math.abs(now - new Date(forecast.time));
+
+		for (const entry of timeseries) {
+			const entryTime = new Date(entry.time);
+			const diff = now - entryTime;
+
+			if (diff > 0 && diff < closestDiff) {
+				closestDiff = diff;
+				forecast = entry;
+			}
+		}
+
+		const forecastXHours = this.#getForecastForXHours(forecast.data);
+		const stellarInfo = this.#getStellarInfoForDate(new Date(forecast.time));
+
+		const current = {};
+		current.date = new Date(forecast.time);
+		current.temperature = forecast.data.instant.details.air_temperature;
+		current.windSpeed = forecast.data.instant.details.wind_speed;
+		current.windFromDirection = forecast.data.instant.details.wind_from_direction;
+		current.humidity = forecast.data.instant.details.relative_humidity;
+		current.weatherType = this.#convertWeatherType(
+			forecastXHours.summary?.symbol_code,
+			stellarInfo ? this.#isDayTime(current.date, stellarInfo) : true
+		);
+		current.precipitationAmount = forecastXHours.details?.precipitation_amount;
+		current.precipitationProbability = forecastXHours.details?.probability_of_precipitation;
+		current.minTemperature = forecastXHours.details?.air_temperature_min;
+		current.maxTemperature = forecastXHours.details?.air_temperature_max;
+
+		if (stellarInfo) {
+			current.sunrise = new Date(stellarInfo.sunrise.time);
+			current.sunset = new Date(stellarInfo.sunset.time);
+		}
+
+		return current;
+	}
+
+	#generateForecast (data) {
+		const timeseries = data.properties.timeseries;
+		const dailyData = new Map();
+
+		// Collect all data points for each day
+		for (const entry of timeseries) {
+			const date = new Date(entry.time);
+			const dateStr = getDateString(date);
+
+			if (!dailyData.has(dateStr)) {
+				dailyData.set(dateStr, {
+					date: date,
+					temps: [],
+					precip: [],
+					precipProb: [],
+					symbols: []
+				});
+			}
+
+			const dayData = dailyData.get(dateStr);
+
+			// Collect temperature from instant data
+			if (entry.data.instant?.details?.air_temperature !== undefined) {
+				dayData.temps.push(entry.data.instant.details.air_temperature);
+			}
+
+			// Collect data from forecast periods (prefer longer periods to avoid double-counting)
+			const forecast = entry.data.next_12_hours || entry.data.next_6_hours || entry.data.next_1_hours;
+			if (forecast) {
+				if (forecast.details?.precipitation_amount !== undefined) {
+					dayData.precip.push(forecast.details.precipitation_amount);
+				}
+				if (forecast.details?.probability_of_precipitation !== undefined) {
+					dayData.precipProb.push(forecast.details.probability_of_precipitation);
+				}
+				if (forecast.summary?.symbol_code) {
+					dayData.symbols.push(forecast.summary.symbol_code);
+				}
+			}
+		}
+
+		// Convert collected data to forecast objects
+		const days = [];
+		for (const [dateStr, data] of dailyData) {
+			const stellarInfo = this.#getStellarInfoForDate(data.date);
+
+			const dayData = {
+				date: data.date,
+				minTemperature: data.temps.length > 0 ? Math.min(...data.temps) : null,
+				maxTemperature: data.temps.length > 0 ? Math.max(...data.temps) : null,
+				precipitationAmount: data.precip.length > 0 ? Math.max(...data.precip) : null,
+				precipitationProbability: data.precipProb.length > 0 ? Math.max(...data.precipProb) : null,
+				weatherType: data.symbols.length > 0 ? this.#convertWeatherType(data.symbols[0], true) : null
+			};
+
+			if (stellarInfo) {
+				dayData.sunrise = new Date(stellarInfo.sunrise.time);
+				dayData.sunset = new Date(stellarInfo.sunset.time);
+			}
+
+			days.push(dayData);
+		}
+
+		// Sort by date to ensure correct order
+		return days.sort((a, b) => a.date - b.date);
+	}
+
+	#generateHourly (data) {
+		const hours = [];
+		const timeseries = data.properties.timeseries;
+
+		for (const entry of timeseries) {
+			const forecast1h = entry.data.next_1_hours;
+			if (!forecast1h) continue;
+
+			const date = new Date(entry.time);
+			const stellarInfo = this.#getStellarInfoForDate(date);
+
+			const hourly = {
+				date: date,
+				temperature: entry.data.instant.details.air_temperature,
+				windSpeed: entry.data.instant.details.wind_speed,
+				windFromDirection: entry.data.instant.details.wind_from_direction,
+				humidity: entry.data.instant.details.relative_humidity,
+				precipitationAmount: forecast1h.details?.precipitation_amount,
+				precipitationProbability: forecast1h.details?.probability_of_precipitation,
+				weatherType: this.#convertWeatherType(
+					forecast1h.summary?.symbol_code,
+					stellarInfo ? this.#isDayTime(date, stellarInfo) : true
+				)
+			};
+
+			hours.push(hourly);
+		}
+
+		return hours;
+	}
+
+	#getForecastForXHours (data) {
+		const hours = this.config.currentForecastHours;
+
+		if (hours === 12 && data.next_12_hours) {
+			return data.next_12_hours;
+		} else if (hours === 6 && data.next_6_hours) {
+			return data.next_6_hours;
+		} else if (data.next_1_hours) {
+			return data.next_1_hours;
+		}
+
+		return data.next_6_hours || data.next_12_hours || data.next_1_hours || {};
+	}
+
+	#getStellarInfoForDate (date) {
+		if (!this.stellarData) return null;
+
+		const dateStr = getDateString(date);
+
+		for (const day of this.stellarData) {
+			const dayDate = day.date.split("T")[0];
+			if (dayDate === dateStr) {
+				return day;
+			}
+		}
+
+		return null;
+	}
+
+	#isDayTime (date, stellarInfo) {
+		if (!stellarInfo || !stellarInfo.sunrise || !stellarInfo.sunset) {
+			return true;
+		}
+
+		const sunrise = new Date(stellarInfo.sunrise.time);
+		const sunset = new Date(stellarInfo.sunset.time);
+
+		return date >= sunrise && date < sunset;
+	}
+
+	#convertWeatherType (symbolCode, isDayTime) {
+		if (!symbolCode) return null;
+
+		// Yr.no uses symbol codes like "clearsky_day", "partlycloudy_night", etc.
+		const symbol = symbolCode.replace(/_day|_night/g, "");
+
+		const mappings = {
+			clearsky: isDayTime ? "day-sunny" : "night-clear",
+			fair: isDayTime ? "day-sunny" : "night-clear",
+			partlycloudy: isDayTime ? "day-cloudy" : "night-cloudy",
+			cloudy: "cloudy",
+			fog: "fog",
+			lightrainshowers: isDayTime ? "day-showers" : "night-showers",
+			rainshowers: isDayTime ? "showers" : "night-showers",
+			heavyrainshowers: isDayTime ? "day-rain" : "night-rain",
+			lightrain: isDayTime ? "day-sprinkle" : "night-sprinkle",
+			rain: isDayTime ? "rain" : "night-rain",
+			heavyrain: isDayTime ? "rain" : "night-rain",
+			lightsleetshowers: isDayTime ? "day-sleet" : "night-sleet",
+			sleetshowers: isDayTime ? "sleet" : "night-sleet",
+			heavysleetshowers: isDayTime ? "sleet" : "night-sleet",
+			lightsleet: isDayTime ? "day-sleet" : "night-sleet",
+			sleet: "sleet",
+			heavysleet: "sleet",
+			lightsnowshowers: isDayTime ? "day-snow" : "night-snow",
+			snowshowers: isDayTime ? "snow" : "night-snow",
+			heavysnowshowers: isDayTime ? "snow" : "night-snow",
+			lightsnow: isDayTime ? "day-snow" : "night-snow",
+			snow: "snow",
+			heavysnow: "snow",
+			lightrainandthunder: isDayTime ? "day-thunderstorm" : "night-thunderstorm",
+			rainandthunder: isDayTime ? "thunderstorm" : "night-thunderstorm",
+			heavyrainandthunder: isDayTime ? "thunderstorm" : "night-thunderstorm",
+			lightsleetandthunder: isDayTime ? "day-sleet-storm" : "night-sleet-storm",
+			sleetandthunder: isDayTime ? "day-sleet-storm" : "night-sleet-storm",
+			heavysleetandthunder: isDayTime ? "day-sleet-storm" : "night-sleet-storm",
+			lightsnowandthunder: isDayTime ? "day-snow-thunderstorm" : "night-snow-thunderstorm",
+			snowandthunder: isDayTime ? "day-snow-thunderstorm" : "night-snow-thunderstorm",
+			heavysnowandthunder: isDayTime ? "day-snow-thunderstorm" : "night-snow-thunderstorm"
+		};
+
+		return mappings[symbol] || null;
+	}
+
+	#getForecastUrl () {
+		const { lat, lon, altitude } = this.config;
+		return `${this.config.apiBase}/locationforecast/${this.config.forecastApiVersion}/complete?altitude=${altitude}&lat=${lat}&lon=${lon}`;
+	}
+
+	#getSunriseUrl () {
+		const { lat, lon } = this.config;
+		const today = getDateString(new Date());
+		const offset = formatTimezoneOffset(-new Date().getTimezoneOffset());
+		return `${this.config.apiBase}/sunrise/${this.config.sunriseApiVersion}/sun?lat=${lat}&lon=${lon}&date=${today}&offset=${offset}`;
+	}
+}
+
+module.exports = YrProvider;