diff --git a/README.md b/README.md index f6b6435..d9d82f1 100644 --- a/README.md +++ b/README.md @@ -129,6 +129,15 @@ npm start Then open the console on its configured port (3000 by default) and launch **M3ter Manager**. The dashboard stays accessible while MQTT reconnects. +If a relay rejects, stalls, or interrupts Manager's WebSocket, the dashboard +falls back to authenticated HTTP updates, waiting five seconds between completed +refreshes. The connection indicator identifies this fallback separately from +MQTT connectivity. WebSockets retry in the background every 30 seconds; receiving +a valid stream update restores live mode and stops polling. Closing Manager or +ending its session stops these retries. Requests time out after 15 seconds so a +stalled relay cannot leave a refresh pending indefinitely. This requires no new +configuration and does not change the Console's MQTT connection or authentication. + ### Architecture and API Console is public. Only Manager's API and live stream require a Manager session. @@ -181,7 +190,7 @@ event identity, handles `up`, `ack`, `txack`, `join`, `location`, `log`, and `st and reconnects/resubscribes without creating another client when a meter changes. Monitoring persistence and the existing collector are isolated consumers. A unique client ID is generated for each Console process. -The current decoder accepts **only FPort 2, 74 or 106 bytes**. It wraps the +The usage-report decoder accepts **FPort 2, 74 or 106 bytes**. It wraps the existing `decodePayload` implementation: uint32 BE nonce; uint32 BE energy divided by 1,000,000; 64-byte Ed25519 signature; uint16 BE voltage divided by 10; optional 32-byte public key. Existing console keys and subsequently learned keys support @@ -200,9 +209,9 @@ bounded queries. Uplinks deduplicate by ChirpStack event ID, or by a stable tupl of device/event type/source time/frame counter/payload when an ID is absent. Identical values with distinct events are preserved. Without an event ID or source timestamp, events are retained separately rather than risking data loss. -Source timestamps are preserved in metadata; invalid timestamps use receipt time. The Overview's +Usage-report source timestamps are preserved in metadata; invalid timestamps use receipt time. The Overview's Last Uplink uses the persisted console reception time of a successfully decoded, -non-duplicate uplink. MQTT heartbeats, connection events, UI refreshes and decode +non-duplicate FPort 2 uplink. FPort 4, MQTT heartbeats, connection events, UI refreshes and decode errors cannot reset it. Source timestamps still drive the existing Analytics. MQTT payload transport is explicit: native ChirpStack `data` remains Base64; @@ -210,7 +219,64 @@ hex producers supply `dataHex` or `data` with `dataEncoding: "hex"`. Hex must co complete byte pairs, without separators or a `0x` prefix. No alphabet guessing is used. Both collector and Manager use the same byte conversion. Live Monitoring shows the hexadecimal bytes and preserves the original field, encoding, and text -for inspection. Downlink encoding and firmware decoders are unchanged. +for inspection. The collector still receives only usage reports; monitoring never +causes an energy acknowledgment or a blockchain operation. + +#### FPort 4 electrical monitoring + +`src/m3ter/electrical.ts` implements the supplied Switch Cumulus version 1 layout: +exactly 97 bytes, big-endian, with signed active/reactive power, power factor, and +temperature. Other lengths/versions are retained as diagnostics without updating +meter state. Unsupported uplink ports are ignored. FPort 4 is never a downlink port. +Live Monitoring displays per-phase voltage/current/power/power factor, neutral +currents, frequency, temperature, cumulative forward/reverse counters, and reported +relay/phase/PGA status. No FPort 2 value substitutes for missing FPort 4 data. + +Native ChirpStack `data` is Base64. A valid `object` with `type: "telemetry"` is +preferred; unknown/incomplete schemas fall back to raw bytes. The current normalized +object adapter accepts `version`, `flags`, `uptime`, `voltage`/`current` (`a,b,c`), +`activePower`/`reactivePower`/`powerFactor`/`forwardEnergy`/`reverseEnergy` +(`a,b,c,total`), `neutralMeasured`, `neutralCalculated`, `frequency`, and `temperature`. +All values are already scaled in the units displayed. `type: "report"` objects +can supply `nonce`, `energy` (kWh), `voltage` (V), and `signature` (hex); raw report +bytes are still required for independent signature verification. Values are never +rescaled a second time. Original codec objects, payload text, and encoding are retained +for inspection. The referenced firmware files, `telemetry.md`, and upstream +`tools/chirpstack-codec.js` were not available in this checkout during implementation; +the adapter's compatibility with that codec's actual field names still needs verification. +Raw-byte support follows the complete layout supplied in the development request. + +Monitoring uses the actual ChirpStack `time`, retaining Console receipt time +separately. A missing/invalid measurement timestamp rejects that frame as a +diagnostic rather than substituting a UI refresh clock. Metadata includes device, +application, frame counter, deduplication ID, gateways, RSSI/SNR, and decoder source. +Deduplication uses the event ID, otherwise device/frame counter and observed boot +session (allowing counters to restart); a bounded persistent recent-key window +also protects against replay after history eviction. Delayed/equal-time frames +cannot replace the latest state or add energy. + +Per-channel forward/reverse differences are calculated in integer counter units. +The first frame establishes a baseline. Lower uptime starts a new boot baseline +without adding reset energy or erasing observed totals. An unexplained counter +decrease retains that channel's high-water baseline until recovery or reboot, +avoiding artificial consumption. Persistent totals mean **observed increases since +monitoring began**, not complete lifetime or billing totals. Gaps may omit power +samples but do not invalidate later counter differences. Average positive total +power × elapsed time / 3,600,000 is an advisory cross-check; a discrepancy greater +than max(0.01 kWh, 50% of the estimate) is explained, never used to rewrite counters. + +Freshness is separate from MQTT status and FPort 2 activity: stale after three +estimated intervals. Three consistent observed gaps establish cadence; otherwise +the last requested interval is explicitly provisional, or the 60-second firmware +default is labeled as cadence unknown. Enable/disable requests remain unverified; +subsequent frames provide evidence, and silence alone never proves disablement. + +Additive `manager_electrical_readings` and `manager_electrical_state` tables keep +monitoring separate from usage accounting. Raw frames remain in `manager_events`. +Both new tables are initialized safely on an existing database; no original table +is rebuilt. `GET /api/m3ter-manager/devices/:devEui/telemetry` provides the latest +state and paginated monitoring history (50 rows, `offset` parameter), protected by +the existing Manager session and application scope. Charts plot **raw accumulator snapshots**, not independent interval consumption. Repeated and growing values with the same nonce stay pending. A consecutive nonce @@ -222,7 +288,7 @@ are flagged, not credited as fresh consumption. Manager sends no automatic ackno Firmware source is not present here: observed transitions cannot establish unobserved energy, reset causes, downlink execution, or blockchain settlement. -The database retains **100 uplink records globally by default**, including malformed +The database retains **100 usage-report records globally by default**, including malformed payloads. Set optional `M3TER_TELEMETRY_LIMIT` to a positive integer to change this limit. Invalid values log a warning and safely fall back to 100. The limit applies on startup and after every insertion, and prunes their raw event copies too. A separate small per-device state @@ -230,10 +296,30 @@ preserves the pending nonce/high-water mark and latest reading after eviction or restart. Existing history is replayed once before migration trims it. Non-telemetry activity, command history, device configuration and all original Console tables are preserved. SQLite reuses freed pages; migration does not rewrite or vacuum unrelated tables. Date ranges cover the retained window only. +FPort 4 has a separate **global cap using the same `M3TER_TELEMETRY_LIMIT`** (default +100), including monitoring decode failures and raw event copies. Thus up to 100 +usage reports plus 100 monitoring records are retained by default. FPort 4 cannot +evict usage history. Monitoring baselines, latest sample, and observed totals survive +both pruning and process restarts. Command records and original Console data are untouched. ### Command safety and delivery evidence -All 13 command types and their listed parameter variations are defined centrally. +All existing command types remain, with four additional telemetry actions (three +firmware command codes) defined centrally: + +| Action | FPort | Hex | Base64 | +| --- | --- | --- | --- | +| Enable telemetry | 2 | `2301` | `IwE=` | +| Disable telemetry | 2 | `2300` | `IwA=` | +| Telemetry interval: 60 seconds | 2 | `24003C` | `JAA8` | +| Telemetry interval: 300 seconds | 2 | `24012C` | `JAEs` | +| Request Telemetry Now | 2 | `25` | `JQ==` | + +Intervals are 10–65535 seconds; disable requires confirmation. Firmware v1.0.4+ +is required for these new operations, and older-meter support is not inferred +merely from device discovery. Existing preview, idempotency, history, and queue +controls apply to all new actions. + The backend reconstructs payloads from IDs and validated integer parameters, enforces lengths and FPorts 2/3, and rejects raw payload/FPort overrides. Class B, calibration, and FUOTA ports 200–202 are not exposed. Billing, restart, relay diff --git a/src/m3ter/api.ts b/src/m3ter/api.ts index aef81b1..b0db9e5 100644 --- a/src/m3ter/api.ts +++ b/src/m3ter/api.ts @@ -6,6 +6,7 @@ import { applicationId, chirpstackRest, deviceDetails, deviceId, getDevice, list import { commandCatalogue, generateCommand } from './commands'; import { checkActivity, inactiveMilliseconds, managerEvents, monitoring } from './monitor'; import * as store from './store'; +import { electricalSnapshot, electricalHistory } from './electrical-store'; import { managerAuthRouter, requireManagerAuth, managerAuthenticated, managerSessions } from './auth'; export const managerRouter = Router(); @@ -42,7 +43,7 @@ managerRouter.get('/devices/:devEui', wrap(async (req, res) => { const devEui = deviceId(req.params.devEui), application = applicationId(); const details = await deviceDetails(devEui); store.updateDevice(application, devEui, details); - res.json({ device: details, state: store.deviceState(application, devEui), latest: store.latestReading(application, devEui) }); + res.json({ device: details, state: store.deviceState(application, devEui), latest: store.latestReading(application, devEui), electrical: electricalSnapshot(application, devEui) }); })); managerRouter.get('/devices/:devEui/history', wrap((req, res) => { const devEui = deviceId(req.params.devEui), application = applicationId(); @@ -50,7 +51,11 @@ managerRouter.get('/devices/:devEui/history', wrap((req, res) => { const from = integer(req.query.from, to - 86400000, 0, to); if (to - from > 366 * 86400000) throw new ManagerError('Choose a range of at most 366 days.'); res.json({ ...store.history(application, devEui, from, to, integer(req.query.offset, 0, 0, 1_000_000), integer(req.query.limit, 50, 1, 100)), - latest: store.latestReading(application, devEui), state: store.deviceState(application, devEui), monitoring }); + latest: store.latestReading(application, devEui), state: store.deviceState(application, devEui), monitoring, electrical: electricalSnapshot(application, devEui) }); +})); +managerRouter.get('/devices/:devEui/telemetry', wrap((req, res) => { + const application = applicationId(), devEui = deviceId(req.params.devEui); + res.json({ ...electricalSnapshot(application,devEui), ...electricalHistory(application,devEui,integer(req.query.offset,0,0,1_000_000)) }); })); managerRouter.get('/devices/:devEui/events', wrap((req, res) => { res.json({ events: store.events(applicationId(), deviceId(req.params.devEui), integer(req.query.offset, 0, 0, 1_000_000)) }); diff --git a/src/m3ter/commands.ts b/src/m3ter/commands.ts index 93cd34a..8210288 100644 --- a/src/m3ter/commands.ts +++ b/src/m3ter/commands.ts @@ -2,6 +2,7 @@ export type CommandDefinition = { id: string; name: string; category: string; fPort: 2 | 3; code: number; description: string; confirmation?: string; options?: { value: number; label: string }[]; min?: number; max?: number; defaultValue?: number; + fixedValue?: number; }; const gain = [1, 2, 4].map(value => ({ value, label: `×${value}` })); const billing = 'The relay will change state, the energy accumulator will reset to zero, and the nonce will increment.'; @@ -19,6 +20,10 @@ export const commandCatalogue: CommandDefinition[] = [ { id: 'phase-mode', name: 'Phase mode', category: 'Phase configuration', fPort: 2, code: 0x22, options: [{ value: 0, label: 'Three-phase' }, { value: 1, label: 'Phase A' }, { value: 2, label: 'Phase B' }, { value: 3, label: 'Phase C' }], description: 'Select reported phases without resetting energy. Three-phase reports total energy and the SUM of phase voltages (about 690 V on a 230 V system). A queued mode is not verified configuration.' }, { id: 'class-a', name: 'Switch to Class A', category: 'LoRaWAN class', fPort: 3, code: 0, description: 'Downlinks become available only after an uplink.', confirmation: 'Switch to Class A? Future downlinks must wait for an uplink. Class C is the normal operating mode.' }, { id: 'class-c', name: 'Switch to Class C', category: 'LoRaWAN class', fPort: 3, code: 2, description: 'Request the normal Class C operating mode. A reachable Class C meter can receive downlinks without waiting for an uplink.' }, + { id: 'telemetry-enable', name: 'Enable telemetry', category: 'Monitoring telemetry', fPort: 2, code: 0x23, fixedValue: 1, description: 'Enable periodic FPort 4 electrical monitoring (firmware v1.0.4+). Subsequent frames provide evidence of operation; queue acceptance is not confirmation.' }, + { id: 'telemetry-disable', name: 'Disable telemetry', category: 'Monitoring telemetry', fPort: 2, code: 0x23, fixedValue: 0, description: 'Stop periodic monitoring; FPort 2 usage reports continue.', confirmation: 'Disable periodic FPort 4 telemetry? Monitoring will become stale. Silence alone cannot confirm that the setting was applied.' }, + { id: 'telemetry-interval', name: 'Set telemetry interval', category: 'Monitoring telemetry', fPort: 2, code: 0x24, min: 10, max: 65535, defaultValue: 60, description: 'Set the FPort 4 monitoring interval in seconds. Below 60 seconds uses more LoRaWAN airtime. This does not change the FPort 2 usage-report interval.' }, + { id: 'telemetry-now', name: 'Request Telemetry Now', category: 'Monitoring telemetry', fPort: 2, code: 0x25, description: 'Request one FPort 4 frame immediately, even when periodic monitoring is disabled (firmware v1.0.4+).' }, ]; export function generateCommand(id: unknown, value?: unknown) { @@ -35,7 +40,8 @@ export function generateCommand(id: unknown, value?: unknown) { bytes.push(value >> 8, value & 255); } } else if (value !== undefined && value !== null) throw new Error('This command takes no parameters'); - const expectedLength = command.min !== undefined ? 3 : command.options ? 2 : 1; + if (command.fixedValue !== undefined) bytes.push(command.fixedValue); + const expectedLength = command.min !== undefined ? 3 : command.options || command.fixedValue !== undefined ? 2 : 1; if (bytes.length !== expectedLength || ![2, 3].includes(command.fPort)) throw new Error('Invalid command frame'); const payload = Buffer.from(bytes); return { id: command.id, name: command.name, description: command.description, fPort: command.fPort, diff --git a/src/m3ter/decoder.ts b/src/m3ter/decoder.ts index 571ef4e..7a102c9 100644 --- a/src/m3ter/decoder.ts +++ b/src/m3ter/decoder.ts @@ -1,12 +1,13 @@ import { decodePayload } from '../lib/decode'; import { verifyPayloadSignature } from '../lib/utils'; +import { decodeElectrical, ElectricalTelemetry } from './electrical'; export type Telemetry = { decoder: string; nonce: number; rawEnergy: number; energy: number; rawVoltage: number; voltage: number; signature: string; publicKey: string | null; verificationKey: string | null; verification: 'verified' | 'invalid' | 'unverified'; }; // Additional firmware ports can register their own decoder without changing raw event storage. -export const telemetryDecoders = new Map Telemetry>([[2, (data, knownKey) => { +export const telemetryDecoders = new Map Telemetry | ElectricalTelemetry>([[2, (data, knownKey) => { if (![74, 106].includes(data.length)) throw new Error('FPort 2 requires exactly 74 or 106 bytes'); const decoded = decodePayload(data); const publicKey = decoded.extensions.deviceId || null; @@ -14,10 +15,26 @@ export const telemetryDecoders = new Map const verification = key ? (verifyPayloadSignature(data, Buffer.from(key.replace(/^0x/, ''), 'hex')) ? 'verified' : 'invalid') : 'unverified'; return { decoder: 'switch-cumulus-v1', nonce: decoded.nonce, rawEnergy: data.readUInt32BE(4), energy: decoded.energy, rawVoltage: data.readUInt16BE(72), voltage: decoded.extensions.voltage!, signature: decoded.signature, publicKey, verificationKey: key?.replace(/^0x/, '') || null, verification }; -}]]); +}], [4, decodeElectrical]]); -export function decodeTelemetry(fPort: number, data: Buffer, knownKey?: string): Telemetry { +export function decodeTelemetry(fPort: 2, data: Buffer, knownKey?: string): Telemetry; +export function decodeTelemetry(fPort: 4, data: Buffer, knownKey?: string): ElectricalTelemetry; +export function decodeTelemetry(fPort: number, data: Buffer, knownKey?: string): Telemetry | ElectricalTelemetry; +export function decodeTelemetry(fPort: number, data: Buffer, knownKey?: string): Telemetry | ElectricalTelemetry { const decode = telemetryDecoders.get(fPort); if (!decode) throw new Error(`No telemetry decoder for FPort ${fPort}`); return decode(data, knownKey); } + +/** A codec's report object may supply scaled fields; raw bytes still authenticate + * nonce/energy. Never accept an upstream claim that a signature was verified. */ +export function reportObject(value: any, data: Buffer, knownKey?: string): Telemetry | null { + if (!value || value.type !== 'report' || ![74,106].includes(data.length)) return null; + if (value.nonce !== data.readUInt32BE(0) || value.energy !== data.readUInt32BE(4) / 1e6 || value.voltage !== data.readUInt16BE(72) / 10 || + typeof value.signature !== 'string' || value.signature.toLowerCase().replace(/^0x/, '') !== data.subarray(8,72).toString('hex')) return null; + const publicKey = data.length === 106 ? data.subarray(74).toString('hex') : null; + const key = knownKey || publicKey; + return { decoder: 'switch-cumulus-v1', nonce: value.nonce, energy: value.energy, rawEnergy: data.readUInt32BE(4), voltage: value.voltage, + rawVoltage: data.readUInt16BE(72), signature: data.subarray(8,72).toString('hex'), publicKey, verificationKey: key?.replace(/^0x/,'') || null, + verification: key ? (verifyPayloadSignature(data,Buffer.from(key.replace(/^0x/,''),'hex')) ? 'verified' : 'invalid') : 'unverified' }; +} diff --git a/src/m3ter/electrical-store.ts b/src/m3ter/electrical-store.ts new file mode 100644 index 0000000..b3665d2 --- /dev/null +++ b/src/m3ter/electrical-store.ts @@ -0,0 +1,79 @@ +import type { Database } from 'better-sqlite3'; +import type { ManagerEvent } from './store'; +import { ElectricalState, ElectricalTelemetry, trackElectrical } from './electrical'; +let db: Database, limit = 100; + +export function initializeElectricalStore(connection: Database, retentionLimit: number): void { + db = connection; limit = retentionLimit; + db.exec(`CREATE TABLE IF NOT EXISTS manager_electrical_state ( + application TEXT NOT NULL, devEui TEXT NOT NULL, state TEXT NOT NULL, PRIMARY KEY(application,devEui)); + CREATE TABLE IF NOT EXISTS manager_electrical_readings ( + id INTEGER PRIMARY KEY, application TEXT NOT NULL, devEui TEXT NOT NULL, + timestamp INTEGER NOT NULL, receivedAt INTEGER NOT NULL, decoded TEXT NOT NULL, tracking TEXT NOT NULL); + CREATE INDEX IF NOT EXISTS manager_electrical_device_time ON manager_electrical_readings(application,devEui,timestamp DESC,id DESC);`); + db.transaction(trim)(); +} +function trim(): void { + // Separate global cap using the SAME setting: FPort 4 cannot evict usage reports. + db.prepare(`DELETE FROM manager_electrical_readings WHERE id IN ( + SELECT id FROM manager_events WHERE kind IN ('telemetry','telemetry-error') ORDER BY timestamp DESC,id DESC LIMIT -1 OFFSET ?)`).run(limit); + db.prepare(`DELETE FROM manager_events WHERE kind IN ('telemetry','telemetry-error') AND id NOT IN ( + SELECT id FROM manager_events WHERE kind IN ('telemetry','telemetry-error') ORDER BY timestamp DESC,id DESC LIMIT ?)`).run(limit); +} +export function electricalState(application: string, devEui: string): ElectricalState | null { + const row: any = db.prepare('SELECT state FROM manager_electrical_state WHERE application=? AND devEui=?').get(application, devEui); + return row ? JSON.parse(row.state) : null; +} +export function recordElectrical(event: ManagerEvent, telemetry: ElectricalTelemetry | undefined, add: () => number | null): boolean { + return db.transaction(() => { + const previous = electricalState(event.application, event.devEui!); + if (previous?.seen.includes(event.eventKey)) return false; + const id = add(); if (id === null) return false; + if (telemetry) { + const state = trackElectrical(previous, { telemetry, timestamp: event.timestamp, receivedAt: event.receivedAt, + rawPayload: event.rawPayload ?? null, metadata: event.metadata }, event.eventKey); + const late = previous && event.timestamp <= previous.latest.timestamp; + db.prepare(`INSERT INTO manager_electrical_readings(id,application,devEui,timestamp,receivedAt,decoded,tracking) VALUES(?,?,?,?,?,?,?)`) + .run(id, event.application, event.devEui, event.timestamp, event.receivedAt, JSON.stringify(telemetry), JSON.stringify(late ? { status: 'late-frame', forward: null, reverse: null } : state.tracking)); + db.prepare(`INSERT INTO manager_electrical_state(application,devEui,state) VALUES(?,?,?) + ON CONFLICT(application,devEui) DO UPDATE SET state=excluded.state`).run(event.application,event.devEui,JSON.stringify(state)); + } + trim(); return true; + })(); +} +function request(application: string, devEui: string, ids: string[]): any { + const row: any = db.prepare(`SELECT timestamp,status,command FROM manager_commands WHERE application=? AND devEui=? + AND json_extract(command,'$.id') IN (${ids.map(() => '?').join(',')}) + ORDER BY timestamp DESC,rowid DESC LIMIT 1`).get(application,devEui,...ids); + return row ? { ...row, command: JSON.parse(row.command), applied: false } : null; +} +export function electricalSnapshot(application: string, devEui: string, now = Date.now()) { + const state = electricalState(application,devEui); + const intervalRequest = request(application,devEui,['telemetry-interval']); + const modeRequest = request(application,devEui,['telemetry-enable','telemetry-disable']); + const immediateRequest = request(application,devEui,['telemetry-now']); + const spacing = [...(state?.spacing || [])].sort((a,b) => a-b); + const median = spacing.length ? spacing[Math.floor(spacing.length / 2)] : 60; + const regular = spacing.length >= 3 && spacing.every(n => Math.abs(n-median) <= median * 0.2); + const pendingInterval = intervalRequest && !['failed','cleared'].includes(intervalRequest.status) ? intervalRequest.command.value : null; + const interval = regular ? median : pendingInterval || 60; + const staleAfter = interval * 3 * 1000; + const freshness = !state ? 'unavailable' : now - state.latest.timestamp > staleAfter ? 'stale' : 'fresh'; + let status = 'Unknown · no FPort 4 telemetry observed. It may be disabled or unsupported by this firmware.'; + if (state) status = 'Telemetry observed · periodic enable/disable state is unverified.'; + if (regular && freshness === 'fresh') status = 'Regular telemetry observed · periodic operation inferred, not acknowledged.'; + if (modeRequest && !['failed','cleared'].includes(modeRequest.status)) { + if (modeRequest.command.id === 'telemetry-disable') status = 'Disable requested · application is unverified; silence alone is not confirmation.'; + else status = state && state.latest.receivedAt > modeRequest.timestamp ? + 'Enable requested · subsequent telemetry observed; periodic operation is not definitively confirmed.' : 'Enable requested · awaiting telemetry evidence.'; + } + return { state: state ? { latest: state.latest, totals: state.totals, tracking: state.tracking, startedAt: state.startedAt } : null, freshness, status, expectedInterval: interval, + staleAfter, intervalRequest, modeRequest, immediateRequest, retentionLimit: limit, + intervalBasis: regular ? 'observed estimate' : pendingInterval ? 'requested interval; application unverified' : 'provisional firmware default; cadence unknown' }; +} +export function electricalHistory(application: string, devEui: string, offset = 0) { + const rows = db.prepare(`SELECT r.*,e.rawPayload,e.metadata,e.fPort FROM manager_electrical_readings r JOIN manager_events e ON e.id=r.id + WHERE r.application=? AND r.devEui=? ORDER BY r.timestamp DESC,r.id DESC LIMIT 50 OFFSET ?`).all(application,devEui,offset) as any[]; + const count: any = db.prepare('SELECT COUNT(*) AS total FROM manager_electrical_readings WHERE application=? AND devEui=?').get(application,devEui); + return { rows: rows.map(row => ({ ...row, decoded: JSON.parse(row.decoded), tracking: JSON.parse(row.tracking), metadata: JSON.parse(row.metadata) })), total: count.total, offset, limit: 50, retentionLimit: limit }; +} diff --git a/src/m3ter/electrical.ts b/src/m3ter/electrical.ts new file mode 100644 index 0000000..c1d7107 --- /dev/null +++ b/src/m3ter/electrical.ts @@ -0,0 +1,97 @@ +/** Switch Cumulus v1 monitoring, FPort 4. Usage accounting remains in decoder.ts. */ +export type Phases = { a: number; b: number; c: number }; +export type Totals = Phases & { total: number }; +export type ElectricalTelemetry = { + type: 'telemetry'; version: 1; flags: number; uptime: number; + phaseMode: 'three-phase' | 'a' | 'b' | 'c'; relayClosed: boolean; relayFitted: boolean; + currentPga: number | null; voltagePga: number | null; + voltage: Phases; current: Phases; neutralMeasured: number; neutralCalculated: number; + activePower: Totals; reactivePower: Totals; powerFactor: Totals; + frequency: number; temperature: number; forwardEnergy: Totals; reverseEnergy: Totals; +}; +export const phases = ['a', 'b', 'c'] as const; +export const channels = ['a', 'b', 'c', 'total'] as const; +export function decodeFlags(flags: number) { + return { phaseMode: (['three-phase', 'a', 'b', 'c'] as const)[flags & 3], + relayClosed: !!(flags & 4), relayFitted: !!(flags & 8), + currentPga: [1, 2, 4][(flags >> 4) & 3] ?? null, + voltagePga: [1, 2, 4][(flags >> 6) & 3] ?? null }; +} +export function validateElectricalFrame(bytes: Buffer): void { + if (bytes.length !== 97) throw new Error('FPort 4 requires exactly 97 bytes'); + if (bytes[0] !== 1) throw new Error(`Unsupported FPort 4 format version ${bytes[0]}`); +} +export function decodeElectrical(bytes: Buffer): ElectricalTelemetry { + validateElectricalFrame(bytes); + const three = (offset: number): Phases => ({ a: bytes.readUInt16BE(offset) / 100, b: bytes.readUInt16BE(offset + 2) / 100, c: bytes.readUInt16BE(offset + 4) / 100 }); + const four = (offset: number, size: number, scale: number, signed: boolean): Totals => Object.fromEntries(channels.map((key, i) => + [key, (signed ? bytes.readIntBE(offset + size * i, size) : bytes.readUIntBE(offset + size * i, size)) / scale])) as Totals; + return { type: 'telemetry', version: 1, flags: bytes[1], uptime: bytes.readUInt32BE(2), ...decodeFlags(bytes[1]), + voltage: three(6), current: three(12), neutralMeasured: bytes.readUInt16BE(18) / 100, neutralCalculated: bytes.readUInt16BE(20) / 100, + activePower: four(22, 4, 10, true), reactivePower: four(38, 4, 10, true), powerFactor: four(54, 2, 1000, true), + frequency: bytes.readUInt16BE(62) / 100, temperature: bytes.readInt8(64), + forwardEnergy: four(65, 4, 100000, false), reverseEnergy: four(81, 4, 100000, false) }; +} + +/** Validate a normalized codec object without treating its scaled values as bytes. */ +export function electricalObject(value: any): ElectricalTelemetry | null { + const number = (v: unknown, min: number, max: number, scale = 1): boolean => typeof v === 'number' && Number.isFinite(v) && v >= min && v <= max && Math.abs(v * scale - Math.round(v * scale)) < 0.00001; + if (!value || value.type !== 'telemetry' || value.version !== 1 || !number(value.flags, 0, 255) || !number(value.uptime, 0, 0xffffffff)) return null; + for (const key of ['voltage', 'current']) if (!phases.every(p => number(value[key]?.[p], 0, 655.35, 100))) return null; + for (const key of ['activePower', 'reactivePower']) if (!channels.every(p => number(value[key]?.[p], -214748364.8, 214748364.7, 10))) return null; + if (!channels.every(p => number(value.powerFactor?.[p], -32.768, 32.767, 1000))) return null; + for (const key of ['forwardEnergy', 'reverseEnergy']) if (!channels.every(p => number(value[key]?.[p], 0, 42949.67295, 100000))) return null; + if (!number(value.neutralMeasured, 0, 655.35, 100) || !number(value.neutralCalculated, 0, 655.35, 100) || + !number(value.frequency, 0, 655.35, 100) || !number(value.temperature, -128, 127)) return null; + const copy = (group: any, keys: readonly string[]) => Object.fromEntries(keys.map(p => [p, group[p]])); + return { type: 'telemetry', version: 1, flags: value.flags, uptime: value.uptime, ...decodeFlags(value.flags), + voltage: copy(value.voltage, phases) as Phases, current: copy(value.current, phases) as Phases, + neutralMeasured: value.neutralMeasured, neutralCalculated: value.neutralCalculated, + activePower: copy(value.activePower, channels) as Totals, reactivePower: copy(value.reactivePower, channels) as Totals, + powerFactor: copy(value.powerFactor, channels) as Totals, frequency: value.frequency, temperature: value.temperature, + forwardEnergy: copy(value.forwardEnergy, channels) as Totals, reverseEnergy: copy(value.reverseEnergy, channels) as Totals }; +} + +export type ElectricalSample = { timestamp: number; receivedAt: number; telemetry: ElectricalTelemetry; rawPayload: string | null; metadata: Record }; +export type ElectricalState = { + latest: ElectricalSample; totals: { forward: Totals; reverse: Totals }; baseline: { forward: Totals; reverse: Totals }; startedAt: number; + spacing: number[]; seen: string[]; session: number; + tracking: { status: string; forward: Record; reverse: Record; + estimatedForward: number | null; discrepancy: boolean; elapsed: number | null }; +}; +const zero = (): Totals => ({ a: 0, b: 0, c: 0, total: 0 }); +const unknown = () => ({ a: null, b: null, c: null, total: null }); +/** Observed differences only; the first frame and reset frames establish baselines. */ +export function trackElectrical(previous: ElectricalState | null, sample: ElectricalSample, key: string): ElectricalState { + const result: ElectricalState = previous ? JSON.parse(JSON.stringify(previous)) : { + latest: sample, totals: { forward: zero(), reverse: zero() }, baseline: { forward: { ...sample.telemetry.forwardEnergy }, reverse: { ...sample.telemetry.reverseEnergy } }, startedAt: sample.timestamp, spacing: [], seen: [], session: 0, + tracking: { status: 'baseline', forward: unknown(), reverse: unknown(), estimatedForward: null, discrepancy: false, elapsed: null }, + }; + result.seen = [...result.seen.slice(-255), key]; + if (previous && sample.timestamp <= previous.latest.timestamp) return result; + const t = sample.telemetry, old = previous?.latest.telemetry; + result.latest = sample; + result.tracking = { status: old ? 'tracked' : 'baseline', forward: unknown(), reverse: unknown(), estimatedForward: null, discrepancy: false, elapsed: null }; + if (!old) return result; + if (t.uptime < old.uptime) { + result.tracking.status = 'restart'; result.spacing = []; result.session++; + result.baseline = { forward: { ...t.forwardEnergy }, reverse: { ...t.reverseEnergy } }; return result; + } + const elapsed = (sample.timestamp - previous!.latest.timestamp) / 1000; + result.tracking.elapsed = elapsed; + if (elapsed >= 1 && elapsed <= 7 * 86400) result.spacing = [...result.spacing.slice(-7), elapsed]; + for (const direction of ['forward', 'reverse'] as const) for (const channel of channels) { + const group = direction === 'forward' ? 'forwardEnergy' : 'reverseEnergy'; + const delta = Math.round(t[group][channel] * 100000) - Math.round(result.baseline[direction][channel] * 100000); + if (delta < 0) { result.tracking.status = 'counter-decrease'; continue; } + result.tracking[direction][channel] = delta / 100000; + result.baseline[direction][channel] = t[group][channel]; + result.totals[direction][channel] = Math.round((result.totals[direction][channel] + delta / 100000) * 100000) / 100000; + } + // Sparse samples can miss load changes; flag an observation, never rewrite counters. + const estimate = (Math.max(0, old.activePower.total) + Math.max(0, t.activePower.total)) / 2 * elapsed / 3600000; + result.tracking.estimatedForward = estimate; + const measured = result.tracking.forward.total; + result.tracking.discrepancy = measured !== null && Math.abs(measured - estimate) > Math.max(0.01, estimate * 0.5); + return result; +} diff --git a/src/m3ter/monitor.ts b/src/m3ter/monitor.ts index 05e8dcd..06089e2 100644 --- a/src/m3ter/monitor.ts +++ b/src/m3ter/monitor.ts @@ -1,6 +1,8 @@ import { EventEmitter } from 'events'; import { createHash, randomUUID } from 'crypto'; -import { decodeTelemetry } from './decoder'; +import { decodeTelemetry, reportObject } from './decoder'; +import { electricalObject, validateElectricalFrame } from './electrical'; +import { recordElectrical, electricalState } from './electrical-store'; import * as store from './store'; import { applicationId, deviceId } from './chirpstack'; import { getMeterByDevEui } from '../store/sqlite'; @@ -41,15 +43,20 @@ export function ingestEvent(topic: string, blob: Buffer): boolean { const receivedAt = Date.now(), parsedTime = Date.parse(event.time); const timestamp = Number.isFinite(parsedTime) && parsedTime > 0 && parsedTime < receivedAt + 300_000 ? parsedTime : receivedAt; const kind = parts[3].toLowerCase(); + if (kind === 'up' && ![2,4].includes(event.fPort)) return false; const fields = [event.time, event.fCnt, event.devAddr, event.data, event.queueItemId, event.acknowledged, event.downlinkId]; + if (event.fPort === 4 && event.object !== undefined) fields.push(event.object); if (event.dataHex !== undefined || event.dataEncoding !== undefined) fields.push(event.dataHex, event.dataEncoding); - const identity = event.deduplicationId || (event.time ? fields : randomUUID()); - const eventKey = createHash('sha256').update(JSON.stringify([devEui, kind, identity])).digest('hex'); + const identity = event.deduplicationId || (event.fPort === 4 && Number.isInteger(event.fCnt) ? ['fCnt',event.fCnt,event.devAddr || ''] : event.time ? fields : randomUUID()); + const eventKey = createHash('sha256').update(JSON.stringify(event.fPort === 4 ? [devEui,kind,4,identity] : [devEui,kind,identity])).digest('hex'); const rx = Array.isArray(event.rxInfo) ? event.rxInfo[0] : null; const metadata: Record = { sourceTime: typeof event.time === 'string' ? event.time.slice(0,100) : null, timestampSource: timestamp === parsedTime ? 'ChirpStack' : 'console receipt', name: String(event.deviceInfo.deviceName || devEui).slice(0, 200), applicationName: String(event.deviceInfo.applicationName || '').slice(0, 200), deviceProfileName: String(event.deviceInfo.deviceProfileName || '').slice(0, 200), fCnt: Number.isInteger(event.fCnt) ? event.fCnt : null, rssi: typeof rx?.rssi === 'number' ? rx.rssi : null, snr: typeof rx?.snr === 'number' ? rx.snr : null, gatewayId: typeof rx?.gatewayId === 'string' ? rx.gatewayId.slice(0, 32) : null }; + metadata.applicationId = application; metadata.deduplicationId = typeof event.deduplicationId === 'string' ? event.deduplicationId.slice(0,200) : null; + metadata.gateways = Array.isArray(event.rxInfo) ? event.rxInfo.slice(0,32).map((r: any) => ({ gatewayId: r?.gatewayId, rssi: r?.rssi, snr: r?.snr, time: r?.time })) : []; + if (event.object !== undefined) metadata.originalCodecObject = JSON.stringify(event.object).slice(0,16384); const suppliedPayload = event.dataHex !== undefined ? event.dataHex : event.data; const rawPayload = typeof suppliedPayload === 'string' ? suppliedPayload.slice(0, 4096) : null; metadata.payloadField = event.dataHex !== undefined ? 'dataHex' : 'data'; @@ -58,16 +65,41 @@ export function ingestEvent(topic: string, blob: Buffer): boolean { const record: store.ManagerEvent = { application, devEui, kind, source: 'ChirpStack', timestamp, receivedAt, eventKey, rawPayload, fPort: Number.isInteger(event.fPort) ? event.fPort : null, metadata, message: `ChirpStack ${kind} event` }; let inserted: boolean; - if (kind === 'up') { + if (kind === 'up' && event.fPort === 4) { + record.kind = 'telemetry'; record.message = 'FPort 4 electrical telemetry received'; + let telemetry; + try { + if (timestamp !== parsedTime) throw new Error('FPort 4 requires a valid ChirpStack measurement time'); + const payload = suppliedPayload === undefined ? null : uplinkPayload(event); + if (payload) { validateElectricalFrame(payload.bytes); metadata.payloadHex = payload.hex; } + const object = electricalObject(event.object); + // Raw framing and object framing must agree; unknown schemas use raw fallback. + telemetry = object && (!payload || object.flags === payload.bytes[1] && object.uptime === payload.bytes.readUInt32BE(2)) ? object : + payload ? decodeTelemetry(4,payload.bytes) : undefined; + if (!telemetry) throw new Error('Missing valid FPort 4 payload or telemetry object'); + if (!event.deduplicationId && Number.isInteger(event.fCnt)) { + const previous = electricalState(application,devEui); + const restart = previous && timestamp > previous.latest.timestamp && telemetry.uptime < previous.latest.telemetry.uptime; + const session = (previous?.session || 0) + (restart ? 1 : 0); + record.eventKey = createHash('sha256').update(JSON.stringify([devEui,4,identity,session])).digest('hex'); + } + metadata.decodedSource = telemetry === object ? 'ChirpStack object' : 'raw payload'; + if (event.object && telemetry !== object) metadata.codecWarning = 'Unsupported or invalid telemetry object; decoded raw payload instead'; + } catch (error) { record.kind = 'telemetry-error'; record.message = (error as Error).message; } + inserted = recordElectrical(record,telemetry,() => store.addEvent(record)); + if (inserted) store.updateDevice(application,devEui,metadata); + } else if (kind === 'up') { let telemetry; try { const payload = uplinkPayload(event); metadata.payloadHex = payload.hex; const knownKey = store.deviceState(application, devEui)?.publicKey || getMeterByDevEui(devEui)?.publicKey; - telemetry = decodeTelemetry(event.fPort, payload.bytes, knownKey); + telemetry = reportObject(event.object,payload.bytes,knownKey); + metadata.decodedSource = telemetry ? 'ChirpStack object' : 'raw payload'; + telemetry = telemetry || decodeTelemetry(2, payload.bytes, knownKey); record.message = telemetry.verification === 'invalid' ? 'Telemetry decoded; signature INVALID. Voltage is outside the signed fields.' : 'Uplink decoded'; } catch (error) { record.kind = 'decode-error'; record.message = (error as Error).message; } - inserted = store.recordUplink(record, telemetry, inactiveMilliseconds()); + inserted = store.recordUplink(record, telemetry || undefined, inactiveMilliseconds()); } else { if (kind === 'location') { const location = validLocation(event.location); diff --git a/src/m3ter/store.ts b/src/m3ter/store.ts index 5573bbd..287bb4c 100644 --- a/src/m3ter/store.ts +++ b/src/m3ter/store.ts @@ -3,6 +3,7 @@ import { randomUUID } from 'crypto'; import type { Telemetry } from './decoder'; import { advance, Accumulator } from './accumulator'; import { telemetryLimit } from './config'; +import { initializeElectricalStore } from './electrical-store'; let db: Database; let retentionLimit = 100; export function initializeManagerStore(connection: Database): void { @@ -60,6 +61,7 @@ export function initializeManagerStore(connection: Database): void { } trimHistory(); })(); + initializeElectricalStore(db, retentionLimit); // A process may have stopped after the upstream accepted a command. Never resend automatically. db.prepare("UPDATE manager_commands SET status='unknown', detail='Console restarted during enqueue; inspect the queue before retrying' WHERE status='enqueuing'").run(); } diff --git a/src/public/css/m3ter-manager.css b/src/public/css/m3ter-manager.css index 5fba011..01cdbb8 100644 --- a/src/public/css/m3ter-manager.css +++ b/src/public/css/m3ter-manager.css @@ -83,3 +83,10 @@ .mm-login-card input { width:100%; min-width:0; min-height:44px; background:var(--surface); color:var(--text); border:1px solid var(--border); border-radius:var(--small-radius); padding:10px 12px; } .mm-login-card #mm-login-error { color:var(--text); border-left:3px solid #d45f69; padding-left:12px; } .mm-login-card .mm-mark { width:52px; height:52px; } + +.mm-phase-grid { display:grid; grid-template-columns:repeat(3,minmax(0,1fr)); gap:12px; } +.mm-phase-grid .mm-info { grid-template-columns:1fr; } +.mm-phase-grid .mm-info dt { border:0; padding-bottom:0; } +#mm-electrical-main { margin-top:18px; } +#mm-electrical-tracking { overflow-wrap:anywhere; } +@container (max-width:520px) { .mm-phase-grid { grid-template-columns:1fr; } } diff --git a/src/public/js/m3ter-commands.js b/src/public/js/m3ter-commands.js index 47a68ff..bde202e 100644 --- a/src/public/js/m3ter-commands.js +++ b/src/public/js/m3ter-commands.js @@ -28,7 +28,7 @@ node('p', 'Unconfirmed downlink. Acceptance into the queue does not verify delivery or execution.', 'mm-note')]; if (command.confirmation) parts.push(node('p', command.confirmation, 'mm-notice')); if (command.parameter) parts.splice(1, 0, node('p', `Selected setting: ${command.parameter}`, 'mm-notice')); - if (id === 'report-interval' && value < 60) parts.push(node('p', 'Short intervals consume more LoRaWAN airtime.', 'mm-notice')); + if (['report-interval','telemetry-interval'].includes(id) && value < 60) parts.push(node('p', 'Short intervals consume more LoRaWAN airtime.', 'mm-notice')); display(command.name, parts, 'Enqueue command', command.requiresConfirmation); notice(''); } catch (error) { showError(error); } } @@ -69,10 +69,10 @@ control = node('select'); control.setAttribute('aria-label', command.name); command.options.forEach(option => { const item = node('option', option.label); item.value = option.value; control.append(item); }); } else if (command.min !== undefined) { - const presets = node('select'); presets.setAttribute('aria-label', 'Report interval presets'); + const presets = node('select'); presets.setAttribute('aria-label', command.id === 'telemetry-interval' ? 'Telemetry interval presets' : 'Report interval presets'); [10,15,30,60,300,900,1800,3600].forEach(seconds => { const option = node('option', seconds < 60 ? `${seconds} seconds` : `${seconds / 60} minutes`); option.value = seconds; presets.append(option); }); const custom = node('option', 'Custom'); custom.value = 'custom'; presets.append(custom); presets.value = '60'; - control = node('input'); control.type = 'number'; control.min = command.min; control.max = command.max; control.step = 1; control.value = command.defaultValue; control.setAttribute('aria-label', 'Report interval seconds'); + control = node('input'); control.type = 'number'; control.min = command.min; control.max = command.max; control.step = 1; control.value = command.defaultValue; control.setAttribute('aria-label', command.id === 'telemetry-interval' ? 'Telemetry interval seconds' : 'Report interval seconds'); presets.addEventListener('change', () => { if (presets.value !== 'custom') control.value = presets.value; }); control.addEventListener('input', () => { presets.value = 'custom'; }); card.append(presets); } diff --git a/src/public/js/m3ter-electrical.js b/src/public/js/m3ter-electrical.js new file mode 100644 index 0000000..1f21a00 --- /dev/null +++ b/src/public/js/m3ter-electrical.js @@ -0,0 +1,72 @@ +(function () { + 'use strict'; + const $ = id => document.getElementById(id); + const el = (tag, text = '', className = '') => { const e = document.createElement(tag); e.textContent = text; if (className) e.className = className; return e; }; + const fixed = (n, precision = 2) => typeof n === 'number' && Number.isFinite(n) ? n.toFixed(precision) : '—'; + const date = n => n ? new Date(n).toLocaleString() : 'Unavailable'; + let snapshot = null, rendered = ''; + function list(values) { + const dl = el('dl', '', 'mm-info'); + for (const [name, value] of values) dl.append(el('dt', name), el('dd', value)); + return dl; + } + function metric(name, value, unit) { + const card = el('article', '', 'mm-metric'), strong = el('strong', value); + strong.append(el('em', ' ' + unit)); card.append(el('span', name), strong); return card; + } + function tick() { + const state = snapshot?.state, latest = state?.latest; + const age = latest ? Math.max(0, Math.floor((Date.now() - latest.timestamp) / 1000)) : null; + const stale = latest && Date.now() - latest.timestamp > snapshot.staleAfter; + $('mm-telemetry-freshness').textContent = !latest ? 'Telemetry unavailable' : `${stale ? 'Stale' : 'Fresh'} telemetry · ${age < 60 ? age + 's' : age < 3600 ? Math.floor(age / 60) + 'm' : Math.floor(age / 3600) + 'h'} ago`; + $('mm-telemetry-freshness').dataset.state = latest && !stale ? 'active' : 'inactive'; + } + function render(next) { + snapshot = next; + const fingerprint = JSON.stringify(next); + if (fingerprint === rendered) { tick(); return; } + rendered = fingerprint; + const state = next?.state, sample = state?.latest, t = sample?.telemetry; + const status = next?.status || 'Unknown · monitoring telemetry has not been observed.'; + $('mm-telemetry-mode').textContent = status; + $('mm-telemetry-command-status').textContent = status + (next?.intervalRequest ? ` Last requested interval: ${next.intervalRequest.command.value}s (${next.intervalRequest.status}; application unverified).` : ''); + $('mm-telemetry-time').textContent = `FPort 4 measurement: ${date(sample?.timestamp)}`; + $('mm-telemetry-cadence').textContent = `Stale after ${fixed((next?.staleAfter || 180000) / 1000, 0)} seconds · ${next?.intervalBasis || 'cadence unknown'}. MQTT connectivity is separate from telemetry freshness.`; + $('mm-electrical-empty').hidden = !!t; $('mm-electrical-data').hidden = !t; + for (const id of ['mm-electrical-main','mm-electrical-phases','mm-electrical-neutral','mm-electrical-status','mm-electrical-energy','mm-electrical-tracking']) $(id).replaceChildren(); + $('mm-electrical-raw').textContent = ''; + if (!t) { tick(); return; } + $('mm-electrical-main').append(metric('Total active power',fixed(t.activePower.total,1),'W'), metric('Total reactive power',fixed(t.reactivePower.total,1),'var'), + metric('Total power factor',fixed(t.powerFactor.total,3),''), metric('Frequency',fixed(t.frequency),'Hz'), metric('Metering chip temperature',fixed(t.temperature,0),'°C')); + for (const phase of ['a','b','c']) { + const card = el('article','','mm-command-card'); card.dataset.phase = phase; + card.append(el('h4',`Phase ${phase.toUpperCase()}`), list([ + ['Voltage',`${fixed(t.voltage[phase])} V`],['Current',`${fixed(t.current[phase])} A`], + ['Active power',`${fixed(t.activePower[phase],1)} W`],['Reactive power',`${fixed(t.reactivePower[phase],1)} var`],['Power factor',fixed(t.powerFactor[phase],3)], + ])); $('mm-electrical-phases').append(card); + } + $('mm-electrical-neutral').append(metric('Measured neutral current',fixed(t.neutralMeasured),'A'),metric('Calculated neutral current',fixed(t.neutralCalculated),'A')); + $('mm-electrical-status').append(list([ + ['Uptime',`${Math.floor(t.uptime / 86400)}d ${Math.floor(t.uptime / 3600) % 24}h ${Math.floor(t.uptime / 60) % 60}m ${t.uptime % 60}s`], + ['Phase mode',t.phaseMode === 'three-phase' ? 'Three-phase' : `Phase ${t.phaseMode.toUpperCase()}`], + ['Relay',t.relayClosed ? 'Closed (reported)' : 'Open (reported)'],['Relay fitted',t.relayFitted ? 'Yes' : 'No'], + ['Current PGA',t.currentPga === null ? 'Unknown / reserved flag' : `×${t.currentPga}`], + ['Voltage PGA',t.voltagePga === null ? 'Unknown / reserved flag' : `×${t.voltagePga}`],['Received by Console',date(sample.receivedAt)], + ])); + for (const phase of ['a','b','c','total']) { + const card = el('article','','mm-command-card'); + card.append(el('h4',phase === 'total' ? 'Total energy' : `Phase ${phase.toUpperCase()} energy`),list([ + ['Forward counter',`${fixed(t.forwardEnergy[phase],5)} kWh`],['Reverse counter',`${fixed(t.reverseEnergy[phase],5)} kWh`], + ['Forward increase',`${fixed(state.tracking.forward?.[phase],5)} kWh`],['Reverse increase',`${fixed(state.tracking.reverse?.[phase],5)} kWh`], + ['Observed forward total',`${fixed(state.totals.forward[phase],5)} kWh`],['Observed reverse total',`${fixed(state.totals.reverse[phase],5)} kWh`], + ])); $('mm-electrical-energy').append(card); + } + const explanations = { baseline: 'First frame establishes a baseline; no prior consumption is inferred.', restart: 'Uptime decreased: restart detected. New baselines established; observed totals preserved.', + 'counter-decrease': 'Counter decrease without an uptime reset: affected increases are unknown. High-water baselines are retained to avoid double counting.', tracked: 'Counter increases tracked between valid frames.' }; + $('mm-electrical-tracking').append(el('p',explanations[state.tracking.status] || state.tracking.status),el('p',`Observed totals since ${date(state.startedAt)} exclude unknown energy before the first frame and across resets. They are not billing or guaranteed lifetime totals.`)); + if (state.tracking.estimatedForward !== null) $('mm-electrical-tracking').append(el('p',`Power-based estimate for this interval: ${fixed(state.tracking.estimatedForward,5)} kWh. ${state.tracking.discrepancy ? 'Counter increase differs by more than 50% or 0.01 kWh (whichever is larger). Sparse samples or changing loads can explain this; counters were not altered.' : 'Sanity check only; counters were not altered.'}`)); + $('mm-electrical-raw').textContent = `Measurement UTC: ${new Date(sample.timestamp).toISOString()}\nOriginal payload (${sample.metadata.payloadEncoding || 'unavailable'}): ${sample.rawPayload ?? 'Not supplied; decoded object used'}\nHex: ${sample.metadata.payloadHex || 'Not supplied'}\nMetadata: ${JSON.stringify(sample.metadata,null,2)}\nDecoded telemetry: ${JSON.stringify(t,null,2)}`; + tick(); + } + window.M3terElectrical = { render, tick }; +})(); diff --git a/src/public/js/m3ter-manager.js b/src/public/js/m3ter-manager.js index ff30f37..a441acf 100644 --- a/src/public/js/m3ter-manager.js +++ b/src/public/js/m3ter-manager.js @@ -7,23 +7,31 @@ const date = value => value ? new Date(value).toLocaleString() : 'Unavailable'; const fixed = (value, places) => typeof value === 'number' && Number.isFinite(value) ? value.toFixed(places) : '—'; let authenticated = false, authVersion = 0; - let active = false, device = null, latest = null, state = null, config = null, tab = 'overview', monitoring = { state: 'disconnected' }; - let socket, reconnectTimer, clockTimer, refreshTimer, searchTimer, reconnectAttempt = 0, snapshotVersion = 0, searchVersion = 0; + let active = false, device = null, latest = null, state = null, config = null, electrical = null, tab = 'overview', monitoring = { state: 'disconnected' }; + let socket, reconnectTimer, clockTimer, refreshTimer, searchTimer, streamTimer, pollTimer; + let polling = false, pollVersion = 0, snapshotVersion = 0, searchVersion = 0; let devices = [], deviceOffset = 0, historyOffset = 0, eventOffset = 0, historyData = null; function notice(message) { text('mm-notice', message); $('mm-notice').hidden = !message; } function showError(error) { if (!authenticated) return; if (error?.name === 'AbortError') return; text('mm-error', error.message || 'Unable to load meter data. Retry using Refresh.'); $('mm-error').hidden = false; } function clearError() { $('mm-error').hidden = true; } async function api(path, options = {}) { - const version = authVersion; - const response = await fetch('/api/m3ter-manager' + path, { ...options, headers: { 'Content-Type': 'application/json' }, - body: options.body === undefined ? undefined : JSON.stringify(options.body) }); - let data; try { data = await response.json(); } catch { - const detail = response.status === 403 ? 'Request rejected by the server. Reload Console at its current address and retry.' : response.status === 404 ? 'The running backend does not have the Manager API. Deploy the matching Console build.' : 'Check the Console backend and proxy connection.'; - throw new Error(`Meter API returned HTTP ${response.status}. ${detail}`); - } - if (path !== '/session' && version !== authVersion) throw new DOMException('Session changed', 'AbortError'); - if (response.status === 401 && path !== '/session') lock('Your session ended. Sign in again.'); - if (!response.ok) throw new Error(data.error || 'Meter request failed. Please retry.'); return data; + const version = authVersion, controller = new AbortController(); + const timeout = setTimeout(() => controller.abort(), 15000); + try { + const response = await fetch('/api/m3ter-manager' + path, { ...options, signal: controller.signal, cache: 'no-store', headers: { 'Content-Type': 'application/json' }, + body: options.body === undefined ? undefined : JSON.stringify(options.body) }); + let data; try { data = await response.json(); } catch (error) { + if (controller.signal.aborted) throw error; + const detail = response.status === 403 ? 'Request rejected by the server. Reload Console at its current address and retry.' : response.status === 404 ? 'The running backend does not have the Manager API. Deploy the matching Console build.' : 'Check the Console backend and proxy connection.'; + throw new Error(`Meter API returned HTTP ${response.status}. ${detail}`); + } + if (path !== '/session' && version !== authVersion) throw new DOMException('Session changed', 'AbortError'); + if (response.status === 401 && path !== '/session') lock('Your session ended. Sign in again.'); + if (!response.ok) throw new Error(data.error || 'Meter request failed. Please retry.'); return data; + } catch (error) { + if (controller.signal.aborted) throw new Error('Meter request timed out. Check the Console or relay connection and retry.'); + throw error; + } finally { clearTimeout(timeout); } } const commands = M3terCommands({ api, selected: () => device, showError, clearError, notice, element: $, refresh, text, node }); function range() { @@ -39,6 +47,7 @@ return seconds < 60 ? `${seconds}s ago` : seconds < 3600 ? `${Math.floor(seconds / 60)}m ago` : seconds < 86400 ? `${Math.floor(seconds / 3600)}h ago` : `${Math.floor(seconds / 86400)}d ago`; } function renderActivity() { + M3terElectrical.tick(); const status = monitoring.state || 'disconnected'; text('mm-mqtt', `MQTT ${status}`); $('mm-mqtt').dataset.state = status; text('mm-last-message', `Last MQTT message: ${date(monitoring.lastMessage)}`); const last = state?.lastUplink || null, recent = last && Date.now() - last <= (config?.inactiveMilliseconds || 300000); @@ -68,6 +77,7 @@ const link = node('a', 'View device location on OpenStreetMap ↗'); link.href = `https://www.openstreetmap.org/?mlat=${encodeURIComponent(location.latitude)}&mlon=${encodeURIComponent(location.longitude)}#map=15/${encodeURIComponent(location.latitude)}/${encodeURIComponent(location.longitude)}`; link.target = '_blank'; link.rel = 'noopener noreferrer'; $('mm-location').replaceChildren(node('p', `Device location: ${location.latitude}, ${location.longitude} · ChirpStack location event`), link); } + M3terElectrical.render(electrical); renderActivity(); } function renderHistory() { @@ -112,7 +122,7 @@ }); eventOffset += data.events.length; $('mm-events-more').hidden = data.events.length < 100; } - async function refresh(telemetryOnly = false) { + async function refresh(telemetryOnly = false, background = false) { if (!device) return; const current = device.devEui, version = ++snapshotVersion; let times; try { times = range(); } catch (error) { showError(error); return; } @@ -121,14 +131,15 @@ telemetryOnly ? Promise.resolve({ device, state, latest }) : api(`/devices/${current}`), api(`/devices/${current}/history?${new URLSearchParams({ ...times, offset: historyOffset })}`), ]); if (version !== snapshotVersion || device?.devEui !== current || !active) return; - if (results[0].status === 'fulfilled') { device = { ...device, ...results[0].value.device }; state = results[0].value.state; latest = results[0].value.latest; } - else showError(results[0].reason); - if (results[1].status === 'fulfilled') { historyData = results[1].value; latest = historyData.latest; state = historyData.state; monitoring = historyData.monitoring; renderHistory(); } - else showError(results[1].reason); + if (results[0].status === 'fulfilled') { device = { ...device, ...results[0].value.device }; state = results[0].value.state; latest = results[0].value.latest; if (!telemetryOnly) electrical = results[0].value.electrical || null; } + else if (!background) showError(results[0].reason); + if (results[1].status === 'fulfilled') { historyData = results[1].value; latest = historyData.latest; state = historyData.state; monitoring = historyData.monitoring; electrical = historyData.electrical || null; renderHistory(); } + else if (!background) showError(results[1].reason); renderInfo(); $('mm-selected').setAttribute('aria-busy', 'false'); if (tab === 'live') await loadEvents().catch(showError); if (tab === 'commands') await commands.loadHistory().catch(showError); if (tab === 'queue') await commands.loadQueue().catch(showError); + return results[1].status === 'fulfilled'; } async function loadDevices(append = false) { const version = ++searchVersion, search = $('mm-search').value.trim(); @@ -150,7 +161,7 @@ } function selectDevice(devEui) { snapshotVersion++; device = devices.find(item => item.devEui === devEui) || (device?.devEui === devEui ? device : null); - latest = null; state = null; historyData = null; historyOffset = 0; commands.close(); + latest = null; state = null; electrical = null; M3terElectrical.render(null); historyData = null; historyOffset = 0; commands.close(); $('mm-empty').hidden = !!device; $('mm-selected').hidden = !device; clearError(); notice(''); for (const view of ['overview','history']) for (const field of ['energy','voltage']) $(`mm-${view}-${field}`).replaceChildren(node('p', 'Loading readings…', 'mm-note')); ['mm-readings','mm-events','mm-command-history','mm-queue'].forEach(id => $(id).replaceChildren()); @@ -164,27 +175,72 @@ if (next === 'commands') commands.loadHistory().catch(showError); if (next === 'queue') commands.loadQueue().catch(showError); } + function stopPolling() { polling = false; pollVersion++; clearTimeout(pollTimer); } + function startPolling() { + if (polling || !active || !authenticated) return; + polling = true; + const version = ++pollVersion; + text('mm-feed', 'Live feed unavailable · checking HTTP updates…'); + $('mm-feed').title = 'The WebSocket could not be maintained. Authenticated HTTP requests keep readings updated without changing the MQTT connection.'; + async function poll() { + let available = false; + try { + if (device) available = await refresh(true, true); + else { + const result = await api('/config'); + if (version !== pollVersion || !active) return; + monitoring = result.monitoring; renderActivity(); available = true; + } + } catch { /* Status below reports failure; 401 is handled by the existing login boundary. */ } + if (version !== pollVersion || !active || !authenticated) return; + text('mm-feed', available ? 'Updates every 5s (HTTP fallback)' : 'Automatic updates unavailable · retrying'); + // Schedule after completion: a slow relay cannot accumulate overlapping polls. + pollTimer = setTimeout(poll, 5000); + } + void poll(); + } function connectStream() { if (!active || !authenticated || socket?.readyState === WebSocket.OPEN || socket?.readyState === WebSocket.CONNECTING) return; - text('mm-feed', 'Live feed connecting…'); socket = new WebSocket(`${location.protocol === 'https:' ? 'wss:' : 'ws:'}//${location.host}/m3ter-manager/live`); - const currentSocket = socket; - socket.onopen = () => { if (socket !== currentSocket || !active) return; reconnectAttempt = 0; text('mm-feed', 'Live feed connected'); if (device) refresh().catch(showError); }; - socket.onmessage = event => { + if (!polling) { text('mm-feed', 'Live feed connecting…'); $('mm-feed').title = ''; } + let currentSocket; + try { currentSocket = new WebSocket(`${location.protocol === 'https:' ? 'wss:' : 'ws:'}//${location.host}/m3ter-manager/live`); } + catch { startPolling(); reconnectTimer = setTimeout(connectStream, 30000); return; } + socket = currentSocket; + let receivedUpdate = false; + function armTimeout(milliseconds) { + clearTimeout(streamTimer); + streamTimer = setTimeout(() => { + if (socket !== currentSocket || !active) return; + // Detach a stalled transport before retrying; some relays never finish a handshake. + socket = null; currentSocket.close(); startPolling(); reconnectTimer = setTimeout(connectStream, 30000); + }, milliseconds); + } + armTimeout(10000); + currentSocket.onopen = () => { if (socket === currentSocket && active) armTimeout(10000); }; + currentSocket.onmessage = event => { if (socket !== currentSocket || !active) return; let update; try { update = JSON.parse(event.data); } catch { return; } + if (!['connection','diagnostic','device'].includes(update?.type)) return; + armTimeout(75000); // The server sends a status heartbeat every 30 seconds. + if (!receivedUpdate) { + receivedUpdate = true; stopPolling(); text('mm-feed', 'Live feed connected'); $('mm-feed').title = ''; + if (device) refresh().catch(showError); + } if (update.type === 'connection') { monitoring = update.monitoring; renderActivity(); } if (update.type === 'diagnostic') showError(new Error(update.message)); if (update.type === 'device' && update.devEui === device?.devEui && !refreshTimer) refreshTimer = setTimeout(() => { refreshTimer = null; if (active) refresh(true).catch(showError); }, 500); }; - socket.onerror = () => { if (socket === currentSocket && active) text('mm-feed', 'Live feed connection error'); }; - socket.onclose = event => { if (socket !== currentSocket) return; if (event.code === 4001) { lock('Your session ended. Sign in again.'); return; } text('mm-feed', active ? 'Live feed reconnecting…' : 'Live feed closed'); if (active) reconnectTimer = setTimeout(async () => { - const version = authVersion; - try { const session = await api('/session'); if (version !== authVersion || !active) return; if (!session.authenticated) { lock('Your session ended. Sign in again.'); return; } } catch { /* Retry the stream when the server returns. */ } - if (version === authVersion && active) connectStream(); - }, Math.min(30000, 1000 * 2 ** reconnectAttempt++)); }; + currentSocket.onerror = () => { if (socket === currentSocket && active) startPolling(); }; + currentSocket.onclose = event => { + if (socket !== currentSocket) return; + socket = null; clearTimeout(streamTimer); + if (!active) return; + if (event.code === 4001) { lock('Your session ended. Sign in again.'); return; } + startPolling(); reconnectTimer = setTimeout(connectStream, 30000); + }; } function lock(message = '') { - authVersion++; close(); authenticated = false; config = null; device = null; state = null; latest = null; historyData = null; devices = []; + authVersion++; close(); authenticated = false; config = null; device = null; state = null; latest = null; electrical = null; M3terElectrical.render(null); historyData = null; devices = []; commands.close(true); $('mm-workspace').hidden = true; $('mm-login').hidden = false; $('mm-password').value = ''; $('mm-device').replaceChildren(node('option', 'Choose a meter…')); ['mm-readings','mm-events','mm-command-history','mm-queue','mm-info','mm-dialog-content'].forEach(id => $(id).replaceChildren()); @@ -222,7 +278,7 @@ try { await api('/session', { method: 'DELETE' }); lock(); } catch (error) { showError(new Error('Sign-out could not reach the server. Please retry.')); } }); - function close() { active = false; snapshotVersion++; searchVersion++; clearTimeout(reconnectTimer); clearTimeout(refreshTimer); clearTimeout(searchTimer); clearInterval(clockTimer); refreshTimer = null; socket?.close(); commands.close(); } + function close() { active = false; snapshotVersion++; searchVersion++; stopPolling(); clearTimeout(streamTimer); clearTimeout(reconnectTimer); clearTimeout(refreshTimer); clearTimeout(searchTimer); clearInterval(clockTimer); refreshTimer = null; const previous = socket; socket = null; previous?.close(); text('mm-feed', 'Live feed closed'); commands.close(); } $('mm-device').addEventListener('change', () => selectDevice($('mm-device').value)); $('mm-search').addEventListener('input', () => { clearTimeout(searchTimer); searchTimer = setTimeout(() => loadDevices(), 250); }); $('mm-more-devices').addEventListener('click', () => loadDevices(true)); diff --git a/src/views/layouts/main.hbs b/src/views/layouts/main.hbs index 3277e5d..072fab6 100644 --- a/src/views/layouts/main.hbs +++ b/src/views/layouts/main.hbs @@ -27,6 +27,7 @@ + diff --git a/src/views/partials/m3ter-manager.hbs b/src/views/partials/m3ter-manager.hbs index d83d1d0..2975178 100644 --- a/src/views/partials/m3ter-manager.hbs +++ b/src/views/partials/m3ter-manager.hbs @@ -22,22 +22,33 @@
M3ter Manager

Command preview

diff --git a/tests/fixtures/electrical.cjs b/tests/fixtures/electrical.cjs new file mode 100644 index 0000000..58b9216 --- /dev/null +++ b/tests/fixtures/electrical.cjs @@ -0,0 +1,12 @@ +// Independent byte fixture from the 97-byte layout supplied with the feature. +// Not a captured firmware sample; signed fields deliberately include negatives. +module.exports = function frame(options = {}) { + const b = Buffer.alloc(97); b[0] = options.version ?? 1; b[1] = options.flags ?? 0x9d; + b.writeUInt32BE(options.uptime ?? 86461, 2); + [23012,23123,23234,101,202,303,45,67].forEach((v,i) => b.writeUInt16BE(v,6+i*2)); + [-1001,2002,3003,options.power ?? 4004,-1111,2222,-3333,-2222].forEach((v,i) => b.writeInt32BE(v,22+i*4)); + [-998,999,1000,-950].forEach((v,i) => b.writeInt16BE(v,54+i*2)); + b.writeUInt16BE(5001,62); b.writeInt8(-12,64); + [12345,23456,34567,options.forward ?? 70368,111,222,333,options.reverse ?? 666].forEach((v,i) => b.writeUInt32BE(v,65+i*4)); + return b; +}; diff --git a/tests/logic/electrical.test.ts b/tests/logic/electrical.test.ts new file mode 100644 index 0000000..776f857 --- /dev/null +++ b/tests/logic/electrical.test.ts @@ -0,0 +1,49 @@ +import { decodeElectrical, electricalObject, trackElectrical } from '../../src/m3ter/electrical'; +import { decodeTelemetry } from '../../src/m3ter/decoder'; +const frame = require('../fixtures/electrical.cjs'); +const sample = (options = {}, timestamp = 100000) => ({ telemetry: decodeElectrical(frame(options)), timestamp, receivedAt: timestamp + 100, rawPayload: frame(options).toString('base64'), metadata: {} }); + +test('exact big endian fields, scales, signed values and flags', () => { + expect(decodeTelemetry(4,frame())).toEqual({ type:'telemetry',version:1,flags:0x9d,uptime:86461, + phaseMode:'a',relayClosed:true,relayFitted:true,currentPga:2,voltagePga:4, + voltage:{a:230.12,b:231.23,c:232.34},current:{a:1.01,b:2.02,c:3.03},neutralMeasured:.45,neutralCalculated:.67, + activePower:{a:-100.1,b:200.2,c:300.3,total:400.4},reactivePower:{a:-111.1,b:222.2,c:-333.3,total:-222.2}, + powerFactor:{a:-.998,b:.999,c:1,total:-.95},frequency:50.01,temperature:-12, + forwardEnergy:{a:.12345,b:.23456,c:.34567,total:.70368},reverseEnergy:{a:.00111,b:.00222,c:.00333,total:.00666} }); +}); +test.each([0,74,96,98,106])('rejects invalid length %i before reading offsets', n => expect(() => decodeElectrical(Buffer.alloc(n))).toThrow('exactly 97')); +test.each([0,2,255])('rejects unsupported version %i', version => expect(() => decodeElectrical(frame({version}))).toThrow('version')); +test('unsigned counters and uptime, signed extremes and reserved gain flags', () => { + const b=frame({uptime:0xffffffff,forward:0xffffffff,flags:255});b.writeInt32BE(-2147483648,22);b.writeInt16BE(-32768,54);b.writeInt8(-128,64); + expect(decodeElectrical(b)).toMatchObject({uptime:4294967295,currentPga:null,voltagePga:null,phaseMode:'c',forwardEnergy:{total:42949.67295},activePower:{a:-214748364.8},powerFactor:{a:-32.768},temperature:-128}); + for(const flags of [0,1,2,3,4,8,16,32,64,128]) expect(electricalObject(decodeElectrical(frame({flags})))).toEqual(decodeElectrical(frame({flags}))); +}); +test('valid normalized objects are equivalent; incomplete, wrong types, versions and nonfinite values are rejected', () => { + const t=decodeElectrical(frame()); expect(electricalObject(t)).toEqual(t); + for(const bad of [null,{}, {...t,type:'report'}, {...t,version:2}, {...t,current:{a:1}}, {...t,temperature:128}, {...t,frequency:'50'}, {...t,neutralMeasured:NaN}]) expect(electricalObject(bad)).toBeNull(); +}); +test('gaps accumulate counter differences once, independently per channel and direction', () => { + const first=trackElectrical(null,sample({forward:125000,reverse:500}), 'one'); + expect(first.totals.forward.total).toBe(0); + const b=sample({uptime:86581,forward:127500,reverse:600},220000); b.telemetry.forwardEnergy.a+=.002; + const next=trackElectrical(first,b,'two'); + expect(next.tracking).toMatchObject({status:'tracked',elapsed:120,forward:{total:.025,a:.002},reverse:{total:.001}}); + expect(next.totals.forward.total).toBe(.025); + expect(trackElectrical(next,b,'duplicate').totals).toEqual(next.totals); + expect(trackElectrical(next,sample({},150000),'late').latest).toEqual(next.latest); +}); +test('restart preserves observed totals, while unexplained drops retain high-water baselines', () => { + let state=trackElectrical(null,sample({uptime:100,forward:100000}), 'a'); + state=trackElectrical(state,sample({uptime:160,forward:110000},160000),'b'); + state=trackElectrical(state,sample({uptime:220,forward:100000},220000),'c'); + expect(state.tracking.forward.total).toBeNull();expect(state.tracking.status).toBe('counter-decrease'); + state=trackElectrical(state,sample({uptime:280,forward:110000},280000),'d');expect(state.totals.forward.total).toBe(.1); + state=trackElectrical(state,sample({uptime:10,forward:500},340000),'e'); + expect(state.tracking.status).toBe('restart');expect(state.tracking.forward.total).toBeNull();expect(state.totals.forward.total).toBe(.1); + state=trackElectrical(state,sample({uptime:70,forward:1000},400000),'f');expect(state.totals.forward.total).toBe(.105); +}); +test('power sanity check never rewrites meter counters', () => { + const old=trackElectrical(null,sample({power:6000,forward:0}), 'a'); + const next=trackElectrical(old,sample({power:6000,forward:100000,uptime:86521},160000),'b'); + expect(next.tracking.estimatedForward).toBe(.01);expect(next.tracking.discrepancy).toBe(true);expect(next.tracking.forward.total).toBe(1); +}); diff --git a/tests/logic/manager-commands.test.ts b/tests/logic/manager-commands.test.ts index d76c007..1c3a799 100644 --- a/tests/logic/manager-commands.test.ts +++ b/tests/logic/manager-commands.test.ts @@ -7,12 +7,14 @@ test.each([ ['current-gain', 1, 'IAE=', 2, 2], ['current-gain', 2, 'IAI=', 2, 2], ['current-gain', 4, 'IAQ=', 2, 2], ['voltage-gain', 1, 'IQE=', 2, 2], ['voltage-gain', 2, 'IQI=', 2, 2], ['voltage-gain', 4, 'IQQ=', 2, 2], ['phase-mode', 0, 'IgA=', 2, 2], ['phase-mode', 1, 'IgE=', 2, 2], ['phase-mode', 2, 'IgI=', 2, 2], ['phase-mode', 3, 'IgM=', 2, 2], + ['telemetry-enable', undefined, 'IwE=', 2, 2], ['telemetry-disable', undefined, 'IwA=', 2, 2], + ['telemetry-interval', 60, 'JAA8', 2, 3], ['telemetry-interval', 300, 'JAEs', 2, 3], ['telemetry-now', undefined, 'JQ==', 2, 1], ['class-a', undefined, 'AA==', 3, 1], ['class-c', undefined, 'Ag==', 3, 1], ])('%s %s matches the firmware frame', (id, value, data, fPort, length) => { expect(generateCommand(id, value)).toMatchObject({ data, fPort, length, confirmed: false }); }); -test('catalogue has exactly thirteen supported types and explicit safety controls', () => { - expect(commandCatalogue).toHaveLength(13); +test('catalogue has existing commands plus four telemetry actions and explicit safety controls', () => { + expect(commandCatalogue).toHaveLength(17); for (const id of ['billing-connect','billing-disconnect','restart','relay-drive','relay-fitted','class-a']) expect(generateCommand(id, id === 'relay-drive' || id === 'relay-fitted' ? 1 : undefined).requiresConfirmation).toBe(true); for (const id of ['class-b', 'calibrate', 'fuota', 200, null]) expect(() => generateCommand(id)).toThrow(); }); @@ -26,3 +28,11 @@ test('unsupported parameters are never encoded', () => { for (const value of [-1,4,200,'1']) expect(() => generateCommand('phase-mode',value)).toThrow(); expect(() => generateCommand('relay-on',1)).toThrow(); }); + +test('telemetry intervals are big endian and bounded; new commands cannot use monitoring or FUOTA ports', () => { + expect(generateCommand('telemetry-interval',10).hex).toBe('24000A'); + expect(generateCommand('telemetry-interval',65535).hex).toBe('24FFFF'); + for(const value of [9,65536,-1,1.1,NaN,Infinity,'60',null,undefined]) expect(()=>generateCommand('telemetry-interval',value)).toThrow(); + expect(generateCommand('telemetry-disable').requiresConfirmation).toBe(true); + expect(commandCatalogue.every(c=>c.fPort===2 || c.fPort===3)).toBe(true); +}); diff --git a/tests/logic/manager-decoder.test.ts b/tests/logic/manager-decoder.test.ts index 9073fdb..3541ade 100644 --- a/tests/logic/manager-decoder.test.ts +++ b/tests/logic/manager-decoder.test.ts @@ -1,5 +1,5 @@ import { generateKeyPairSync, sign } from 'crypto'; -import { decodeTelemetry } from '../../src/m3ter/decoder'; +import { decodeTelemetry, reportObject } from '../../src/m3ter/decoder'; import { decodePayload } from '../../src/lib/decode'; const keys = generateKeyPairSync('ed25519'); const publicKey = keys.publicKey.export({ format: 'der', type: 'spki' }).subarray(-32); @@ -25,3 +25,11 @@ test('voltage is explicitly outside the verified signature region', () => { }); test.each([0,1,72,73,75,105,107,112,256])('rejects invalid length %d', length => { expect(() => decodeTelemetry(2,Buffer.alloc(length))).toThrow(); }); test.each([0,1,3,200,201,202])('does not decode unrelated FPort %d', port => { expect(() => decodeTelemetry(port,payload(74))).toThrow(); }); +test('report codec objects retain independent raw-byte signature verification', () => { + const bytes=payload(106), raw=decodeTelemetry(2,bytes); + expect(reportObject({type:'report',...raw},bytes)).toEqual(raw); + expect(reportObject({type:'telemetry',...raw},bytes)).toBeNull(); + expect(reportObject({type:'report',...raw,energy:999},bytes)).toBeNull(); + bytes[8]^=1; + expect(reportObject({type:'report',...raw,signature:bytes.subarray(8,72).toString('hex'),verification:'verified'},bytes)?.verification).toBe('invalid'); +}); diff --git a/tests/store/electrical.test.ts b/tests/store/electrical.test.ts new file mode 100644 index 0000000..6ec0dac --- /dev/null +++ b/tests/store/electrical.test.ts @@ -0,0 +1,87 @@ +import { randomUUID } from 'crypto'; +import setupDatabase, { deleteDatabase } from '../../src/store/sqlite'; +import * as store from '../../src/m3ter/store'; +import { electricalHistory, electricalState, electricalSnapshot } from '../../src/m3ter/electrical-store'; +import { decodeElectrical } from '../../src/m3ter/electrical'; +import { ingestEvent } from '../../src/m3ter/monitor'; +const frame=require('../fixtures/electrical.cjs'); +const application='11111111-1111-4111-8111-111111111111', a='0102030405060708', b='1112131415161718'; +const env=process.env; +beforeEach(()=>{process.env={...env,APPLICATION_ID:application};delete process.env.M3TER_TELEMETRY_LIMIT;setupDatabase('electrical-test.db');}); +afterEach(()=>{deleteDatabase('electrical-test.db');process.env=env;jest.restoreAllMocks();}); +function event(options:any={}) { + return {deduplicationId:randomUUID(),time:new Date(Date.now()-1000).toISOString(),deviceInfo:{devEui:a,applicationId:application,deviceName:'Meter A'}, + fPort:4,fCnt:1,data:frame().toString('base64'),rxInfo:[{gatewayId:'gateway',rssi:-80,snr:8}],...options}; +} +const ingest=(e:any)=>ingestEvent(`application/${application}/device/${e.deviceInfo.devEui}/event/up`,Buffer.from(JSON.stringify(e))); +test('both ports coexist, retain raw metadata, and unsupported ports are ignored',()=>{ + const usage=Buffer.alloc(74);usage.writeUInt32BE(1500000,4);usage.writeUInt16BE(2300,72); + ingest(event({fPort:2,data:usage.toString('base64')}));const original=store.deviceState(application,a); + const e=event();expect(ingest(e)).toBe(true); + expect(store.latestReading(application,a)).toMatchObject({nonce:0,energy:1.5,voltage:230}); + expect(store.deviceState(application,a).lastUplink).toBe(original.lastUplink); + const row=electricalHistory(application,a).rows[0];expect(row).toMatchObject({timestamp:Date.parse(e.time),rawPayload:e.data,fPort:4,metadata:{fCnt:1,deduplicationId:e.deduplicationId,rssi:-80,snr:8,applicationId:application}}); + expect(electricalState(application,a)?.latest.telemetry.voltage.a).toBe(230.12); + for(const fPort of [3,5,200,201,202])expect(ingest(event({fPort}))).toBe(false); +}); +test('deduplicates identifiers, frame counters and replay after eviction without advancing receipt time',()=>{ + process.env.M3TER_TELEMETRY_LIMIT='1';setupDatabase('electrical-test.db'); + const first=event();ingest(first);expect(ingest(first)).toBe(false); + const second=event({deduplicationId:undefined,fCnt:2,time:new Date(Date.now()).toISOString()});ingest(second);expect(ingest({...second,rxInfo:[]})).toBe(false); + expect(ingest(first)).toBe(false);expect(electricalHistory(application,a).total).toBe(1); +}); +test('codec objects and raw Base64 fallback produce equivalent telemetry; invalid objects fall back safely',()=>{ + const t=decodeElectrical(frame());ingest(event({object:t})); + expect(electricalState(application,a)?.latest.metadata.decodedSource).toBe('ChirpStack object'); + ingest(event({deviceInfo:{devEui:b,applicationId:application},object:{type:'report'}})); + expect(electricalState(application,b)?.latest.telemetry).toEqual(t); + expect(electricalState(application,b)?.latest.metadata.decodedSource).toBe('raw payload'); + const later=new Date(Date.now()).toISOString();ingest(event({time:later,data:undefined,object:t})); + expect(electricalState(application,a)?.latest.rawPayload).toBeNull(); +}); +test('malformed version, length and missing time never replace valid monitoring state',()=>{ + ingest(event());const prior=electricalState(application,a)?.latest; + for(const data of [frame({version:2}).toString('base64'),Buffer.alloc(96).toString('base64'),'ABC!'])ingest(event({data})); + ingest(event({time:undefined}));expect(electricalState(application,a)?.latest).toEqual(prior); + expect(store.events(application,a).filter(e=>e.kind==='telemetry-error')).toHaveLength(4); +}); +test('separate global cap protects usage history and persistent baselines on restart and limit changes',()=>{ + process.env.M3TER_TELEMETRY_LIMIT='3';setupDatabase('electrical-test.db'); + const now=Date.now()-100000; + ingest(event({fPort:2,data:Buffer.alloc(74).toString('base64'),time:new Date(now).toISOString()})); + for(let i=0;i<6;i++)ingest(event({deviceInfo:{devEui:i%2?a:b,applicationId:application},fCnt:i,time:new Date(now+i*1000).toISOString(),data:frame({uptime:100+i,forward:100000+i*1000}).toString('base64')})); + expect(electricalHistory(application,a).total+electricalHistory(application,b).total).toBe(3); + expect(store.history(application,a,0,Date.now(),0,50).total).toBe(1); + expect(electricalState(application,a)?.totals.forward.total).toBe(.04); + process.env.M3TER_TELEMETRY_LIMIT='1';setupDatabase('electrical-test.db'); + expect(electricalHistory(application,a).total+electricalHistory(application,b).total).toBe(1); + ingest(event({time:new Date(now+6000).toISOString(),data:frame({uptime:106,forward:106000}).toString('base64')})); + expect(electricalState(application,a)?.totals.forward.total).toBe(.05); + expect(store.accumulatorState(application,a)?.nonce).toBe(0); +}); +test('default cap keeps newest 100 monitoring records globally including decode failures',()=>{ + const now=Date.now()-200000; + for(let i=0;i<102;i++)ingest(event({deviceInfo:{devEui:i%2?a:b,applicationId:application},time:new Date(now+i*1000).toISOString(),fCnt:i})); + expect(electricalHistory(application,a).total+electricalHistory(application,b).total).toBe(100); + ingest(event({data:Buffer.alloc(2).toString('base64')})); + expect(electricalHistory(application,a).total+electricalHistory(application,b).total).toBe(99); + setupDatabase('electrical-test.db');expect(electricalHistory(application,a).total+electricalHistory(application,b).total).toBe(99); +}); +test('restart allows re-used frame counters; delayed frames never replace latest state or inflate totals',()=>{ + const now=Date.now()-5000; + const first=event({deduplicationId:undefined,fCnt:0,time:new Date(now).toISOString(),data:frame({uptime:100}).toString('base64')});ingest(first); + ingest({...first,fCnt:1,time:new Date(now+1000).toISOString(),data:frame({uptime:101,forward:71368}).toString('base64')}); + ingest({...first,time:new Date(now+2000).toISOString(),data:frame({uptime:1,forward:0}).toString('base64')}); + expect(electricalState(application,a)).toMatchObject({session:1,totals:{forward:{total:.01}},tracking:{status:'restart'}}); + const latest=electricalState(application,a)?.latest; + ingest(event({time:new Date(now+500).toISOString(),data:frame({forward:9999999}).toString('base64')})); + expect(electricalState(application,a)?.latest).toEqual(latest);expect(electricalState(application,a)?.totals.forward.total).toBe(.01); +}); +test('freshness uses measurement time, estimates cadence, and never claims applied settings from queue acceptance',()=>{ + const now=Date.now()-1000;ingest(event({time:new Date(now).toISOString()})); + expect(electricalSnapshot(application,a,now+181000).freshness).toBe('stale'); + const id=randomUUID();store.insertCommand(application,a,id,{id:'telemetry-disable'},'disable');store.commandStatus(application,a,id,'queued','Accepted'); + expect(electricalSnapshot(application,a).status).toContain('application is unverified'); + for(let i=1;i<4;i++)ingest(event({time:new Date(now+i*60000).toISOString(),data:frame({uptime:86461+i*60}).toString('base64')})); + expect(electricalSnapshot(application,a)).toMatchObject({expectedInterval:60,intervalBasis:'observed estimate'}); +}); diff --git a/tests/store/manager.test.ts b/tests/store/manager.test.ts index b9ae8fb..6eccf12 100644 --- a/tests/store/manager.test.ts +++ b/tests/store/manager.test.ts @@ -36,7 +36,7 @@ test('malformed lengths, FPorts and identity mismatches do not create readings', const mismatch = event(); mismatch.body.deviceInfo.devEui = b; expect(ingest(mismatch)).toBe(false); expect(ingestEvent(event().topic,Buffer.from('{'))).toBe(false); expect(store.latestReading(app,a)).toBeNull(); expect(store.latestReading(app,b)).toBeNull(); - expect(store.events(app,a).filter(row => row.kind === 'decode-error')).toHaveLength(2); + expect(store.events(app,a).filter(row => row.kind === 'decode-error')).toHaveLength(1); }); test('delivery events correlate by device and queue ID, never by selected meter or transmission alone', () => { const id = randomUUID(); store.insertCommand(app,a,id,{name:'Relay ON'},'fingerprint'); diff --git a/tests/ui/electrical.spec.cjs b/tests/ui/electrical.spec.cjs new file mode 100644 index 0000000..bb441c3 --- /dev/null +++ b/tests/ui/electrical.spec.cjs @@ -0,0 +1,77 @@ +const {test,expect}=require('@playwright/test'); +const {randomUUID}=require('node:crypto'); +test.use({baseURL:'http://127.0.0.1:4174'}); +const api='/api/m3ter-manager', a='0102030405060708', b='1112131415161718', empty='2122232425262728'; +test.beforeEach(async({page,request})=>{ + await page.route(/https:\/\//,route=>route.abort()); + await request.post(api+'/session',{data:{username:'test-manager',password:'test-only-manager-password'}}); +}); +async function open(page) { + await page.goto('/');await page.evaluate(()=>Desktop.launch('m3ter-manager')); + await page.locator('#mm-username').fill('test-manager');await page.locator('#mm-password').fill('test-only-manager-password');await page.locator('#mm-login-submit').click(); + await expect(page.locator('#mm-device option')).toHaveCount(4);await page.locator('#mm-device').selectOption(a); + await expect(page.locator('#mm-selected')).toHaveAttribute('aria-busy','false'); +} +const publish=(request,data)=>request.post('/__test/manager',{data}); +test('FPort 4 live readings stay separate from usage and collector; objects and raw data both work',async({page,request})=>{ + await open(page); + const usage=await page.locator('#mm-energy').textContent(), nonce=await page.locator('#mm-nonce').textContent(); + const before=(await(await publish(request,{action:'stats'})).json()).collectorCount; + await page.locator('[data-mm-tab="live"]').click();await expect(page.locator('#mm-electrical-empty')).toBeVisible(); + await publish(request,{fPort:4,devEui:a,forward:125000}); + await expect(page.locator('#mm-electrical-data')).toBeVisible();await expect(page.locator('#mm-electrical-main')).toContainText('400.4'); + await expect(page.locator('[data-phase="a"]')).toContainText('230.12 V');await expect(page.locator('[data-phase="a"]')).toContainText('-100.1 W'); + await expect(page.locator('#mm-electrical-main')).toContainText('-12'); + await expect(page.locator('#mm-electrical-energy')).toContainText('1.25000 kWh'); + await expect(page.locator('#mm-electrical-status')).toContainText('Closed (reported)'); + expect((await(await publish(request,{action:'stats'})).json()).collectorCount).toBe(before); + await publish(request,{fPort:4,devEui:b,power:-2000,object:true}); + await expect(page.locator('#mm-electrical-main')).toContainText('400.4'); + await page.locator('#mm-device').selectOption(b);await expect(page.locator('#mm-electrical-main')).toContainText('-200.0'); + const result=await(await request.get(`${api}/devices/${b}/telemetry`)).json();expect(result.rows[0].metadata.decodedSource).toBe('ChirpStack object'); + await page.locator('#mm-device').selectOption(a);await page.locator('[data-mm-tab="overview"]').click(); + await expect(page.locator('#mm-energy')).toHaveText(usage);await expect(page.locator('#mm-nonce')).toHaveText(nonce); + await page.locator('[data-mm-tab="live"]').click(); + const latest=(await(await request.get(`${api}/devices/${a}/telemetry`)).json()).state.latest; + await page.clock.setFixedTime(latest.timestamp+181000);await expect(page.locator('#mm-telemetry-freshness')).toContainText('Stale'); + await expect(page.locator('#mm-mqtt')).toHaveText('MQTT connected'); + await page.clock.setFixedTime(Date.now());await page.reload();await page.evaluate(()=>Desktop.launch('m3ter-manager')); + await page.locator('[data-mm-tab="live"]').click();await expect(page.locator('#mm-electrical-energy')).toContainText('1.25000 kWh'); + await page.locator('#mm-device').selectOption(empty);await expect(page.locator('#mm-electrical-empty')).toBeVisible(); + await expect(page.locator('#mm-electrical-data')).toBeHidden(); +}); +test('new command previews and queue requests use exact bytes, selected meter, and safe pending status',async({page,request})=>{ + await open(page);await page.locator('[data-mm-tab="commands"]').click(); + for(const [id,payload] of [['telemetry-enable','IwE='],['telemetry-disable','IwA='],['telemetry-now','JQ==']]) { + await page.locator(`[data-command-id="${id}"]`).click();await expect(page.locator('#mm-dialog-content')).toContainText(`Base64: ${payload}`); + await expect(page.locator('#mm-dialog-content')).toContainText('FPort 2');await expect(page.locator('#mm-dialog-content')).toContainText(a); + if(id==='telemetry-disable'){await expect(page.locator('#mm-submit')).toBeDisabled();await page.locator('#mm-confirm').check();} + await page.locator('#mm-submit').click();await expect(page.locator('#mm-notice')).toContainText('queued'); + } + await page.getByLabel('Telemetry interval presets').selectOption('300');await page.locator('[data-command-id="telemetry-interval"]').click(); + await expect(page.locator('#mm-dialog-content')).toContainText('JAEs');await expect(page.locator('#mm-dialog-content')).toContainText('300 seconds');await page.locator('#mm-submit').click(); + await expect(page.locator('#mm-telemetry-command-status')).toContainText('application unverified'); + const queue=(await(await request.get(`${api}/devices/${a}/queue`)).json()).items; + for(const data of ['IwE=','IwA=','JQ==','JAEs'])expect(queue).toContainEqual(expect.objectContaining({fPort:2,data,confirmed:false})); + const history=(await(await request.get(`${api}/devices/${a}/commands`)).json()).commands; + expect(history.filter(r=>r.command.id.startsWith('telemetry-'))).toHaveLength(4); + expect(history.filter(r=>r.command.id.startsWith('telemetry-')).every(r=>r.devEui===a && r.status==='queued')).toBe(true); + for(const body of [{commandId:'telemetry-interval',value:9},{commandId:'telemetry-interval',value:65536},{commandId:'telemetry-enable',fPort:4},{commandId:'telemetry-disable'}]) + expect((await request.post(`${api}/devices/${a}/commands`,{data:{requestId:randomUUID(),...body}})).status()).toBe(400); + await page.getByLabel('Telemetry interval presets').selectOption('10');await page.locator('[data-command-id="telemetry-interval"]').click(); + await expect(page.locator('#mm-dialog-content')).toContainText('LoRaWAN airtime'); +}); +test('electrical monitoring fits each desktop theme and mobile width',async({page,request})=>{ + await open(page);await publish(request,{fPort:4,devEui:a});await page.locator('[data-mm-tab="live"]').click(); + await expect(page.locator('#mm-electrical-data')).toBeVisible(); + const errors=[];page.on('pageerror',e=>errors.push(e.message)); + for(const width of [1440,768,390,320]) { + await page.setViewportSize({width,height:900}); + for(const theme of ['retro','macos','linux','windows']) { + await page.evaluate(()=>Desktop.launch('settings'));await page.locator(`[data-theme-choice="${theme}"]`).click();await page.evaluate(()=>Desktop.launch('m3ter-manager')); + expect(await page.locator('.mm-scroll').evaluate(e=>e.scrollWidth<=e.clientWidth+1)).toBe(true); + await expect(page.locator('[data-phase="a"]')).toContainText('230.12 V'); + } + } + expect(errors).toEqual([]); +}); diff --git a/tests/ui/manager-fixture.cjs b/tests/ui/manager-fixture.cjs index 5e0e9de..ffdf606 100644 --- a/tests/ui/manager-fixture.cjs +++ b/tests/ui/manager-fixture.cjs @@ -62,6 +62,13 @@ module.exports = async function managerFixture(app) { await handleUplinks(undefined, async () => { collectorCount++; }); function uplink(input = {}) { const id = input.devEui || devices[0].devEui, key = keys.get(id); + if (input.fPort === 4) { + const bytes = require('../fixtures/electrical.cjs')(input); + return {deduplicationId:input.eventId || randomUUID(),time:new Date(input.timestamp || Date.now()).toISOString(), + deviceInfo:{devEui:id,applicationId:application,deviceName:devices.find(d=>d.devEui===id).name}, + data:bytes.toString('base64'),fPort:4,fCnt:input.fCnt ?? 1, + ...(input.object ? {object:require('../../dist/m3ter/electrical').decodeElectrical(bytes)} : {}),rxInfo:[{rssi:-70,snr:9.5,gatewayId:'aabbccddeeff0011'}]}; + } const bytes = Buffer.alloc(input.length || ((input.nonce ?? 0) === 0 ? 106 : 74)); if (bytes.length >= 74) { bytes.writeUInt32BE(input.nonce ?? 0,0); bytes.writeUInt32BE(Math.round((input.energy ?? 12.345678)*1e6),4); sign(null,bytes.subarray(0,8),key.privateKey).copy(bytes,8); bytes.writeUInt16BE(Math.round((input.voltage ?? 230.1)*10),72); diff --git a/tests/ui/manager-relay.spec.cjs b/tests/ui/manager-relay.spec.cjs new file mode 100644 index 0000000..9c2ddcb --- /dev/null +++ b/tests/ui/manager-relay.spec.cjs @@ -0,0 +1,105 @@ +const { test: base, expect } = require('@playwright/test'); +const http = require('node:http'); +const net = require('node:net'); +const meter = '0102030405060708', other = '1112131415161718'; +const upstream = 'http://127.0.0.1:4174'; + +// Exercise real browser upgrades through a relay, including rejected and stalled +// handshakes. No mocked WebSocket or changes to the production auth boundary. +const test = base.extend({ + relay: async ({}, use) => { + const state = { mode: 'reject', histories: 0, failHttp: false }, sockets = new Set(); + const server = http.createServer((req, res) => { + if (req.url.includes('/history?')) { + state.histories++; + if (state.failHttp) { res.writeHead(502); res.end('Relay unavailable'); return; } + } + const outgoing = http.request(upstream + req.url, { method: req.method, headers: req.headers }, response => { + res.writeHead(response.statusCode, response.headers); response.pipe(res); + }); + outgoing.on('error', () => { res.writeHead(502); res.end(); }); + req.pipe(outgoing); + }); + server.on('connection', socket => { sockets.add(socket); socket.on('close', () => sockets.delete(socket)); }); + server.on('upgrade', (req, socket, head) => { + if (state.mode === 'reject') { socket.end('HTTP/1.1 403 Forbidden\r\nConnection: close\r\nContent-Length: 0\r\n\r\n'); return; } + if (state.mode === 'stall') return; + const target = net.connect(4174, '127.0.0.1', () => { + const headers = req.rawHeaders.reduce((all, value, index, values) => index % 2 ? all : `${all}${value}: ${values[index + 1]}\r\n`, ''); + target.write(`${req.method} ${req.url} HTTP/${req.httpVersion}\r\n${headers}\r\n`); + if (head.length) target.write(head); + target.pipe(socket); socket.pipe(target); + }); + target.on('error', () => socket.destroy()); + socket.on('close', () => target.destroy()); + target.on('close', () => socket.destroy()); + }); + await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); + state.url = `http://127.0.0.1:${server.address().port}`; + await use(state); + for (const socket of sockets) socket.destroy(); + await new Promise(resolve => server.close(resolve)); + }, +}); + +async function open(page, relay) { + await page.route(/https:\/\//, route => route.abort()); + await page.goto(relay.url); + await page.evaluate(() => Desktop.launch('m3ter-manager')); + await page.locator('#mm-username').fill('test-manager'); + await page.locator('#mm-password').fill('test-only-manager-password'); + await page.locator('#mm-login-submit').click(); + await expect(page.locator('#mm-device option')).toHaveCount(4); + await page.locator('#mm-device').selectOption(meter); + await expect(page.locator('#mm-selected')).toHaveAttribute('aria-busy', 'false'); +} +const publish = (request, data) => request.post(upstream + '/__test/manager', { data }); +const fallback = page => expect(page.locator('#mm-feed')).toHaveText('Updates every 5s (HTTP fallback)', { timeout: 20000 }); + +test('rejected upgrade falls back to authenticated HTTP, filters meters, and cleans up on close', async ({ page, request, relay }) => { + await open(page, relay); await fallback(page); + const previous = await page.locator('#mm-energy').textContent(); + await publish(request, { devEui: other, energy: 9.123, nonce: 100 }); + const count = relay.histories; + await expect.poll(() => relay.histories, { timeout: 10000 }).toBeGreaterThan(count); + await expect(page.locator('#mm-energy')).toHaveText(previous); + await publish(request, { devEui: meter, energy: 3.456789, voltage: 232.1, nonce: 100 }); + await expect(page.locator('#mm-energy')).toHaveText('3.456789', { timeout: 10000 }); + await expect(page.locator('#mm-voltage')).toHaveText('232.1'); + await expect(page.locator('#mm-mqtt')).toHaveText('MQTT connected'); + const timestamp = await page.locator('#mm-uplink-time').textContent(); + await page.clock.setFixedTime(Date.now() + 120000); + await expect(page.locator('#mm-age')).toHaveText('2m ago'); + const before = relay.histories; + await expect.poll(() => relay.histories, { timeout: 10000 }).toBeGreaterThan(before); + await expect(page.locator('#mm-uplink-time')).toHaveText(timestamp); + await page.locator('#m3ter-manager .window-close').click(); + const closed = relay.histories; + await page.waitForTimeout(6000); // Cross a full polling interval to prove cleanup. + expect(relay.histories).toBe(closed); + await page.evaluate(() => Desktop.launch('m3ter-manager')); + await fallback(page); +}); + +test('stalled upgrade times out and revoked sessions lock HTTP fallback', async ({ page, relay }) => { + relay.mode = 'stall'; + await open(page, relay); await fallback(page); + expect((await page.request.delete(relay.url + '/api/m3ter-manager/session', { headers: { origin: relay.url } })).status()).toBe(200); + await expect(page.locator('#mm-login')).toBeVisible({ timeout: 10000 }); + await expect(page.locator('#mm-workspace')).toBeHidden(); + await expect(page.locator('#mm-login-error')).toContainText('Your session ended'); +}); + +test('HTTP failures are visible and WebSocket recovery stops fallback polling', async ({ page, relay }) => { + await open(page, relay); await fallback(page); + relay.failHttp = true; + await expect(page.locator('#mm-feed')).toHaveText('Automatic updates unavailable · retrying', { timeout: 10000 }); + relay.failHttp = false; + await fallback(page); + relay.mode = 'forward'; + await expect(page.locator('#mm-feed')).toHaveText('Live feed connected', { timeout: 35000 }); + await expect(page.locator('#mm-selected')).toHaveAttribute('aria-busy', 'false'); + const count = relay.histories; + await page.waitForTimeout(6000); + expect(relay.histories).toBe(count); +});