node-red-contrib-hoymiles-home 0.1.1-dev.0

package/.dockerignore

@@ -0,0 +1,3 @@
+.git
+node_modules
+*.md

package/.github/workflows/publish.yml

@@ -0,0 +1,35 @@
+name: Publish to npm
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      - run: npm ci --production
+
+      - name: Determine npm tag
+        id: npm-tag
+        run: |
+          VERSION="${GITHUB_REF#refs/tags/v}"
+          if [[ "$VERSION" == *"-"* ]]; then
+            echo "tag=dev" >> $GITHUB_OUTPUT
+          else
+            echo "tag=latest" >> $GITHUB_OUTPUT
+          fi
+
+      - run: npm publish --access public --tag ${{ steps.npm-tag.outputs.tag }}
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/Dockerfile

@@ -0,0 +1,23 @@
+FROM nodered/node-red:latest
+
+USER root
+
+# Copy the custom node source
+COPY --chown=node-red:node-red . /usr/src/node-red-contrib-hoymiles-home/
+
+# Install the node's own dependencies (axios etc.)
+RUN cd /usr/src/node-red-contrib-hoymiles-home && npm install --production --no-fund
+
+# Bootstrap the Node-RED data dir and install the custom node into it.
+# Named volumes are initialised from the image on first run, so npm packages
+# installed here survive container restarts without a rebuild.
+RUN cd /data && \
+    echo '{"name":"nodered-data","private":true}' > package.json && \
+    npm install /usr/src/node-red-contrib-hoymiles-home --no-fund --no-save && \
+    chown -R node-red:node-red /data
+
+# Copy dev settings and sample flows (only applied when /data volume is fresh)
+COPY --chown=node-red:node-red docker/settings.js /data/settings.js
+COPY --chown=node-red:node-red docker/flows.json   /data/flows.json
+
+USER node-red

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pinguin45orga
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/docker/flows.json

@@ -0,0 +1,43 @@
+[
+    {
+        "id": "tab-hoymiles",
+        "type": "tab",
+        "label": "Hoymiles Test",
+        "disabled": false,
+        "info": "1. Open 'Live Power', set credentials (email + password) and station ID\n2. Deploy and watch the Debug sidebar"
+    },
+    {
+        "id": "cfg-hoymiles",
+        "type": "hoymiles-config",
+        "name": "Hoymiles Account"
+    },
+    {
+        "id": "node-watch",
+        "type": "hoymiles-watch",
+        "name": "Live Power",
+        "server": "cfg-hoymiles",
+        "sid": "",
+        "interval": "",
+        "z": "tab-hoymiles",
+        "x": 180,
+        "y": 200,
+        "wires": [["node-debug"]]
+    },
+    {
+        "id": "node-debug",
+        "type": "debug",
+        "name": "Power (W)",
+        "active": true,
+        "tosidebar": true,
+        "console": false,
+        "tostatus": true,
+        "complete": "payload",
+        "targetType": "msg",
+        "statusVal": "payload.pv",
+        "statusType": "msg",
+        "z": "tab-hoymiles",
+        "x": 380,
+        "y": 200,
+        "wires": []
+    }
+]

package/docker/settings.js

@@ -0,0 +1,35 @@
+module.exports = {
+    // ── Server ────────────────────────────────────────────────────────────────
+    uiPort: process.env.PORT || 1880,
+    uiHost: '0.0.0.0',
+
+    // ── Auth ──────────────────────────────────────────────────────────────────
+    // No admin auth for local dev. Add adminAuth to lock down in production.
+    // adminAuth: { type: 'credentials', users: [{ username: 'admin', password: '...', permissions: '*' }] },
+
+    // ── Credential encryption ─────────────────────────────────────────────────
+    // Value comes from NODE_RED_CREDENTIAL_SECRET env var (set in docker-compose).
+    credentialSecret: process.env.NODE_RED_CREDENTIAL_SECRET || 'hoymiles-dev-secret',
+
+    // ── Flows ─────────────────────────────────────────────────────────────────
+    flowFile: 'flows.json',
+    flowFilePretty: true,
+
+    // ── Editor ────────────────────────────────────────────────────────────────
+    editorTheme: {
+        tours: false,
+        projects: { enabled: false },
+    },
+
+    // ── Logging ───────────────────────────────────────────────────────────────
+    logging: {
+        console: {
+            level: 'info',
+            metric: false,
+            audit: false,
+        },
+    },
+
+    // ── Node settings ─────────────────────────────────────────────────────────
+    functionExternalModules: true,
+};

package/docker-compose.yml

@@ -0,0 +1,19 @@
+services:
+  node-red:
+    build: .
+    image: node-red-contrib-hoymiles-home-dev
+    ports:
+      - "1880:1880"
+    volumes:
+      # Persistent data (flows, credentials, settings).
+      # Initialised from the image on first run; survives container restarts.
+      - node-red-data:/data
+      # Live-reload: mount source directly so node code changes are reflected
+      # after a container restart (no full rebuild needed).
+      - ./nodes:/usr/src/node-red-contrib-hoymiles-home/nodes:ro
+    environment:
+      NODE_RED_CREDENTIAL_SECRET: "${NODE_RED_CREDENTIAL_SECRET:-hoymiles-dev-secret}"
+    restart: unless-stopped
+
+volumes:
+  node-red-data:

package/nodes/hoymiles-config/hoymiles-config.html

@@ -0,0 +1,47 @@
+<script type="text/javascript">
+    RED.nodes.registerType('hoymiles-config', {
+        category: 'config',
+        defaults: {
+            name: { value: '' },
+        },
+        credentials: {
+            email:    { type: 'text' },
+            password: { type: 'password' },
+        },
+        label: function () {
+            return this.name || this.credentials?.email || 'Hoymiles Account';
+        },
+    });
+</script>
+
+<script type="text/html" data-template-name="hoymiles-config">
+    <div class="form-row">
+        <label for="node-config-input-name">
+            <i class="fa fa-tag"></i> Name
+        </label>
+        <input type="text" id="node-config-input-name" placeholder="Hoymiles Account" />
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-email">
+            <i class="fa fa-envelope"></i> E-Mail
+        </label>
+        <input type="email" id="node-config-input-email" placeholder="you@example.com" />
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-password">
+            <i class="fa fa-lock"></i> Password
+        </label>
+        <input type="password" id="node-config-input-password" placeholder="S-Miles Home password" />
+    </div>
+    <div class="form-tips">
+        Use the same credentials as in the <b>S-Miles Home</b> app.
+        The node logs in automatically and refreshes the session token as needed.
+    </div>
+</script>
+
+<script type="text/html" data-help-name="hoymiles-config">
+    <p>Stores the S-Miles Home login credentials and manages the API session token.</p>
+    <p>On deploy the node performs the same two-step login as the S-Miles Home app
+    (pre-inspection → Argon2ID or MD5·SHA256 encoding → token).</p>
+    <p>The resulting token is shared with all connected <b>hoymiles-watch</b> nodes.</p>
+</script>

package/nodes/hoymiles-config/hoymiles-config.js

@@ -0,0 +1,153 @@
+const axios = require('axios');
+const crypto = require('crypto');
+
+const DOMAINS = {
+    eu:      'https://euapi.hoymiles.com',
+    'eu-rt': 'https://eud0.hoymiles.com',
+    global:  'https://neapi.hoymiles.com',
+    in:      'https://indapi.hoymiles.com',
+};
+
+const EU_PREFIXES = ['/iam/', '/dict/', '/hlm/', '/csc/', '/tpa/', '/pvm-ext/', '/iuc/'];
+const EU_RT_PATHS = new Set([
+    '/pvmc/api/0/station_data/real_g_c',
+    '/pvmc/api/0/station_data/eq_day_month_s_c',
+    '/pvmc/api/0/station_data/eq_month_year_s_c',
+    '/pvmc/api/0/station_data/eq_total_year_s_c',
+    '/pvmc/api/0/station_data/p_day_s_c',
+]);
+
+function resolveDomain(path) {
+    if (EU_RT_PATHS.has(path)) return 'eu-rt';
+    if (EU_PREFIXES.some(p => path.startsWith(p))) return 'eu';
+    return 'global';
+}
+
+class APIError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+
+class HoymilesClient {
+    constructor(token, language = 'en_us') {
+        this.token = token;
+        this.language = language;
+    }
+
+    _headers() {
+        const h = {
+            'Content-Type': 'application/json',
+            'Charset': 'UTF-8',
+            'language': this.language,
+            'User-Agent': 'sma/ad/2.9.0/159/0',
+        };
+        if (this.token) h['Authorization'] = this.token;
+        return h;
+    }
+
+    async post(path, data = {}, domain = null) {
+        const base = DOMAINS[domain || resolveDomain(path)];
+        return this._doPost(`${base}${path}`, data);
+    }
+
+    async postUrl(url, data = {}) {
+        return this._doPost(url, data);
+    }
+
+    async _doPost(url, data) {
+        const resp = await axios.post(url, data, {
+            headers: this._headers(),
+            timeout: 30000,
+            maxRedirects: 5,
+        });
+        const result = resp.data;
+        if (!['0', '100'].includes(String(result.status))) {
+            throw new APIError(result.message || 'Unknown error', String(result.status ?? '???'));
+        }
+        return result.data;
+    }
+}
+
+// ── Password encoding (mirrors the CLI exactly) ────────────────────────────
+
+function encodePasswordFallback(password) {
+    const md5 = crypto.createHash('md5').update(password, 'utf8').digest('hex');
+    const sha256 = crypto.createHash('sha256').update(password, 'utf8').digest();
+    return `${md5}.${sha256.toString('base64')}`;
+}
+
+async function encodePasswordArgon2(password, saltHex) {
+    // Lazy-load hash-wasm so the module doesn't fail if the package isn't installed yet
+    const { argon2id } = require('hash-wasm');
+    return argon2id({
+        password,
+        salt: Buffer.from(saltHex, 'hex'),
+        parallelism: 1,
+        iterations: 3,
+        memorySize: 32768,
+        hashLength: 32,
+        outputType: 'hex',
+    });
+}
+
+async function loginWithCredentials(email, password) {
+    const client = new HoymilesClient(); // no token needed for auth endpoints
+
+    // Step 1: pre-inspection — determine password encoding scheme
+    const preinsp = await client.post('/iam/pub/3/auth/pre-insp', { u: email });
+    const { v, a, n } = preinsp || {};
+
+    // Step 2: encode password (Argon2ID when v=3, MD5.Base64(SHA256) otherwise)
+    const ch = (v === 3 && a)
+        ? await encodePasswordArgon2(password, a)
+        : encodePasswordFallback(password);
+
+    // Step 3: login
+    const data = await client.post('/iam/pub/3/auth/login', { u: email, ch, n });
+    const token = data?.token;
+    if (!token) throw new Error('Login succeeded but no token in response');
+    return token;
+}
+
+// ── Node-RED registration ──────────────────────────────────────────────────
+
+module.exports = function (RED) {
+    function HoymilesConfigNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        const email    = node.credentials?.email    || '';
+        const password = node.credentials?.password || '';
+
+        node.client = null;
+
+        if (!email || !password) {
+            node.error('Hoymiles config: email and password are required');
+            node._loginReady = Promise.resolve(); // resolve immediately so dependents don't hang
+            return;
+        }
+
+        // loginReady resolves (never rejects) once the login attempt finishes.
+        // Dependents await this, then check node.client for success/failure.
+        node._loginReady = loginWithCredentials(email, password)
+            .then(token => {
+                node.client = new HoymilesClient(token);
+                node.log(`Logged in as ${email}`);
+            })
+            .catch(err => {
+                node.error(`Login failed: ${err.message}`);
+            });
+    }
+
+    RED.nodes.registerType('hoymiles-config', HoymilesConfigNode, {
+        credentials: {
+            email:    { type: 'text' },
+            password: { type: 'password' },
+        },
+    });
+};
+
+module.exports.APIError = APIError;
+module.exports.HoymilesClient = HoymilesClient;

package/nodes/hoymiles-watch/hoymiles-watch.html

@@ -0,0 +1,92 @@
+<script type="text/javascript">
+    RED.nodes.registerType('hoymiles-watch', {
+        category: 'input',
+        color: '#f0a500',
+        defaults: {
+            name:        { value: '' },
+            server:      { value: '', type: 'hoymiles-config', required: true },
+            sid:         { value: '', required: true, validate: RED.validators.number() },
+            interval:    { value: '' },
+        },
+        inputs: 0,
+        outputs: 1,
+        icon: 'bolt.svg',
+        label: function () {
+            return this.name || `Hoymiles Watch (${this.sid || '?'})`;
+        },
+        labelStyle: function () {
+            return this.name ? 'node_label_italic' : '';
+        },
+        outputLabels: ['live power data'],
+    });
+</script>
+
+<script type="text/html" data-template-name="hoymiles-watch">
+    <div class="form-row">
+        <label for="node-input-name">
+            <i class="fa fa-tag"></i> Name
+        </label>
+        <input type="text" id="node-input-name" placeholder="Hoymiles Watch" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-server">
+            <i class="fa fa-key"></i> Credentials
+        </label>
+        <input type="text" id="node-input-server" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-sid">
+            <i class="fa fa-bolt"></i> Station ID
+        </label>
+        <input type="number" id="node-input-sid" placeholder="e.g. 123456" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-interval">
+            <i class="fa fa-clock-o"></i> Interval (s)
+        </label>
+        <input type="number" id="node-input-interval" placeholder="leave empty to use server value (dly)" min="1" />
+    </div>
+    <div class="form-tips">
+        Leave <b>Interval</b> empty to use the <code>dly</code> field from each server response (matches the S-Miles Home app behaviour).
+    </div>
+</script>
+
+<script type="text/html" data-help-name="hoymiles-watch">
+    <p>Continuously polls the Hoymiles S-Miles Home live power API and emits a message for every new data point.</p>
+
+    <h3>Configuration</h3>
+    <dl class="message-properties">
+        <dt>Credentials</dt>
+        <dd>Select or create a <em>Hoymiles Credentials</em> config node with your API token.</dd>
+        <dt>Station ID</dt>
+        <dd>The numeric station ID (<code>sid</code>). Use the CLI (<code>hoymiles station list</code>) to find it.</dd>
+        <dt>Interval</dt>
+        <dd>Poll interval in seconds. Leave empty to use the <code>dly</code> value returned by the server (recommended — this mirrors the S-Miles Home app).</dd>
+    </dl>
+
+    <h3>Output message</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">object</span></dt>
+        <dd>
+            Power values from the station:
+            <ul>
+                <li><code>payload.pv</code> – Solar generation (W)</li>
+                <li><code>payload.load</code> – Consumption (W)</li>
+                <li><code>payload.grid</code> – Grid exchange (W, negative = export)</li>
+                <li><code>payload.bat</code> – Battery power (W)</li>
+            </ul>
+        </dd>
+        <dt>topic <span class="property-type">string</span></dt>
+        <dd><code>hoymiles/watch/{sid}</code></dd>
+        <dt>sid <span class="property-type">number</span></dt>
+        <dd>The station ID for this message.</dd>
+    </dl>
+
+    <h3>Status indicators</h3>
+    <ul>
+        <li><span style="color:green">●</span> <b>watching</b> – Polling normally</li>
+        <li><span style="color:yellow">◌</span> <b>connecting / reconnecting</b> – Fetching a fresh live URI</li>
+        <li><span style="color:red">●</span> <b>error</b> – Initial connect failed; check credentials and station ID</li>
+        <li><span style="color:grey">◌</span> <b>stopped</b> – Node was disabled or redeployed</li>
+    </ul>
+</script>

package/nodes/hoymiles-watch/hoymiles-watch.js

@@ -0,0 +1,130 @@
+const { APIError } = require('../hoymiles-config/hoymiles-config');
+
+const MIN_INTERVAL_MS   = 1000;
+const DEFAULT_DELAY_MS  = 5000;
+const URI_RETRY_DELAY_MS = 3000;
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+module.exports = function (RED) {
+    function HoymilesWatchNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        const configNode = RED.nodes.getNode(config.server);
+        if (!configNode) {
+            node.error('No Hoymiles credentials configured');
+            node.status({ fill: 'red', shape: 'ring', text: 'no credentials' });
+            return;
+        }
+
+        const sid = parseInt(config.sid, 10);
+        const intervalOverride = config.interval ? parseInt(config.interval, 10) * 1000 : null;
+
+        if (!sid) {
+            node.error('Station ID (sid) is required');
+            node.status({ fill: 'red', shape: 'ring', text: 'no station ID' });
+            return;
+        }
+
+        let running = false;
+        let stopResolve = null;
+        let currentTimer = null;
+
+        async function getLiveUri(client) {
+            const data = await client.post('/pvmc/api/0/station/get_sd_uri_c', { sid });
+            const uri = data?.uri;
+            if (!uri) throw new Error('No live URI returned from get_sd_uri_c');
+            return uri;
+        }
+
+        async function fetchLive(client, uri) {
+            return client.postUrl(uri, { sid, m: 0 });
+        }
+
+        async function interruptibleSleep(ms) {
+            await new Promise(resolve => {
+                stopResolve = resolve;
+                currentTimer = setTimeout(resolve, ms);
+            });
+            stopResolve = null;
+            currentTimer = null;
+        }
+
+        async function watchLoop(client) {
+            node.status({ fill: 'yellow', shape: 'ring', text: 'connecting…' });
+
+            let uri, data;
+            try {
+                uri  = await getLiveUri(client);
+                data = await fetchLive(client, uri);
+            } catch (err) {
+                node.error(`Initial connect failed: ${err.message}`);
+                node.status({ fill: 'red', shape: 'dot', text: 'connect error' });
+                return;
+            }
+
+            node.status({ fill: 'green', shape: 'dot', text: `watching sid=${sid}` });
+
+            while (running) {
+                node.send({ payload: data?.power ?? {}, topic: `hoymiles/watch/${sid}`, sid });
+
+                const dly = intervalOverride ?? Math.max(MIN_INTERVAL_MS, data?.dly ?? DEFAULT_DELAY_MS);
+                await interruptibleSleep(dly);
+
+                if (!running) break;
+
+                try {
+                    data = await fetchLive(client, uri);
+
+                    // No "flow" field → URI has expired, refresh
+                    if (!data || !('flow' in data)) {
+                        uri  = await getLiveUri(client);
+                        data = await fetchLive(client, uri);
+                    }
+                } catch (err) {
+                    node.warn(`Poll error: ${err.message} — refreshing URI`);
+                    node.status({ fill: 'yellow', shape: 'ring', text: 'reconnecting…' });
+                    try { uri = await getLiveUri(client); } catch (_) { /* ignore */ }
+                    await sleep(URI_RETRY_DELAY_MS);
+                    node.status({ fill: 'green', shape: 'dot', text: `watching sid=${sid}` });
+                }
+            }
+
+            node.status({ fill: 'grey', shape: 'ring', text: 'stopped' });
+        }
+
+        function stop() {
+            running = false;
+            if (currentTimer) { clearTimeout(currentTimer); currentTimer = null; }
+            if (stopResolve)  { stopResolve(); stopResolve = null; }
+        }
+
+        async function start() {
+            // Wait for the config node to finish logging in
+            if (configNode._loginReady) {
+                node.status({ fill: 'yellow', shape: 'ring', text: 'authenticating…' });
+                await configNode._loginReady;
+            }
+
+            if (!configNode.client) {
+                node.status({ fill: 'red', shape: 'ring', text: 'auth failed' });
+                return; // error already logged by the config node
+            }
+
+            running = true;
+            await watchLoop(configNode.client);
+        }
+
+        node.on('close', (done) => { stop(); done(); });
+
+        start().catch(err => {
+            node.error(`Startup failed: ${err.message}`);
+            node.status({ fill: 'red', shape: 'dot', text: 'crashed' });
+        });
+    }
+
+    RED.nodes.registerType('hoymiles-watch', HoymilesWatchNode);
+};

package/nodes/hoymiles-watch/icons/bolt.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="-110 -160 540 832">
+  <path fill="white" d="M296 160H180.6l42.6-129.8C227.2 15 215.7 0 200 0H56C44 0 33.8 8.9 32.2 20.8l-32 240C-1.7 275.2 9.5 288 24 288h118.7L96.6 482.5c-3.6 15.2 8 29.5 23.3 29.5 8.4 0 16.4-4.4 20.8-12l176-304c9.3-15.9-2.2-36-20.7-36z"/>
+</svg>

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "node-red-contrib-hoymiles-home",
+  "version": "0.1.1-dev.0",
+  "description": "Node-RED nodes for Hoymiles S-Miles Home API – live power data watch",
+  "author": "Robin Lenz <pinguin45@web.de>",
+  "license": "MIT",
+  "keywords": [
+    "node-red",
+    "hoymiles",
+    "solar",
+    "photovoltaic",
+    "smiles",
+    "smiles home"
+  ],
+  "node-red": {
+    "version": ">=3.0.0",
+    "nodes": {
+      "hoymiles-config": "nodes/hoymiles-config/hoymiles-config.js",
+      "hoymiles-watch": "nodes/hoymiles-watch/hoymiles-watch.js"
+    }
+  },
+  "dependencies": {
+    "axios": "^1.7.0",
+    "hash-wasm": "^4.11.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}