@tempivo/sensor-beacon 1.1.2 → 1.1.4

package/dist/proto/partner-from-proto.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Map ProtoConfig rules (wire) → partner temperatureAlerts + schedule + intervals.
+ * Mirrors scripts/efento-local-mac/partner_rules.py layout (interleaved L/H/OR).
+ */
+import type { TempivoSensorConfiguration } from '../session-types.js';
+import { type ProtoConfigObject } from './decode-proto-config.js';
+/** Decompile ProtoConfig object into partner configuration. */
+export declare function partnerConfigFromProtoObject(cfg: ProtoConfigObject): TempivoSensorConfiguration;
+export declare function partnerConfigFromProtoBase64(b64: string): TempivoSensorConfiguration;

package/dist/proto/partner-from-proto.js

@@ -0,0 +1,187 @@
+import { decodeProtoConfigBase64 } from './decode-proto-config.js';
+const CONDITION_HIGH = 'CONDITION_HIGH_THRESHOLD';
+const CONDITION_LOW = 'CONDITION_LOW_THRESHOLD';
+const CONDITION_LOGIC = 'CONDITION_LOGIC_OPERATOR';
+const CONDITION_DISABLED = 'CONDITION_DISABLED';
+const LOGIC_OR = 'LOGIC_OPERATOR_OR';
+function asNum(v) {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string' && v.trim() !== '' && Number.isFinite(Number(v)))
+        return Number(v);
+    return null;
+}
+function wireTempToC(v) {
+    return v / 10;
+}
+function channelFromMask(mask) {
+    // bit0 = channel 1 ambient, bit2 = channel 3 probe
+    if (mask & 0x4)
+        return 'probe';
+    if (mask & 0x1)
+        return 'ambient';
+    return null;
+}
+function conditionName(c) {
+    if (typeof c === 'string')
+        return c;
+    if (typeof c === 'number') {
+        const map = {
+            1: CONDITION_DISABLED,
+            2: CONDITION_HIGH,
+            3: CONDITION_LOW,
+            6: CONDITION_LOGIC,
+        };
+        return map[c] ?? String(c);
+    }
+    return '';
+}
+function normalizeRules(cfg) {
+    const raw = (cfg.rules ?? cfg.Rules ?? []);
+    if (!Array.isArray(raw))
+        return [];
+    return raw.map((r) => {
+        const o = (r ?? {});
+        const params = (o.parameters ?? o.Parameters ?? []);
+        return {
+            condition: conditionName(o.condition ?? o.Condition),
+            channel_mask: asNum(o.channel_mask ?? o.channelMask) ?? 0,
+            action: o.action ?? o.Action,
+            parameters: params.map((p) => asNum(p) ?? 0),
+        };
+    });
+}
+function actionIsTransmit(action) {
+    const s = String(action ?? '');
+    if (s.includes('TRIGGER_TRANSMISSION'))
+        return true;
+    const n = asNum(action);
+    return n === 3;
+}
+function logicIsOr(params) {
+    if (params.length === 0)
+        return false;
+    const op = params[0];
+    return op === 2 || String(op) === LOGIC_OR || String(op).includes('OR');
+}
+function selectedRuleIds(mask) {
+    const ids = [];
+    for (let i = 0; i < 16; i++) {
+        if (mask & (1 << i))
+            ids.push(i + 1);
+    }
+    return ids;
+}
+/** Decompile ProtoConfig object into partner configuration. */
+export function partnerConfigFromProtoObject(cfg) {
+    const rules = normalizeRules(cfg);
+    const padded = [];
+    for (let i = 0; i < 12; i++) {
+        padded[i] = rules[i] ?? {
+            condition: CONDITION_DISABLED,
+            channel_mask: 0,
+            action: 2,
+            parameters: [],
+        };
+    }
+    const orPairs = new Set();
+    for (const r of padded) {
+        if (r.condition !== CONDITION_LOGIC && !r.condition.includes('LOGIC'))
+            continue;
+        if (!logicIsOr(r.parameters))
+            continue;
+        const ids = selectedRuleIds(r.parameters[1] ?? 0);
+        if (ids.length === 2)
+            orPairs.add(`${ids[0]},${ids[1]}`);
+    }
+    const used = new Array(12).fill(false);
+    const alerts = [];
+    for (let i = 0; i <= 10; i++) {
+        if (used[i] || used[i + 1])
+            continue;
+        const low = padded[i];
+        const high = padded[i + 1];
+        const lowOk = low.condition === CONDITION_LOW || low.condition.includes('LOW_THRESHOLD');
+        const highOk = high.condition === CONDITION_HIGH || high.condition.includes('HIGH_THRESHOLD');
+        if (!lowOk || !highOk)
+            continue;
+        const inferred = alerts.length === 0 ? 'ambient' : 'probe';
+        const ch = channelFromMask(low.channel_mask) ?? channelFromMask(high.channel_mask) ?? inferred;
+        const lowC = wireTempToC(low.parameters[0] ?? 0);
+        const highC = wireTempToC(high.parameters[0] ?? 0);
+        const hyst = wireTempToC(low.parameters[1] ?? 10);
+        const hasReturn = orPairs.has(`${i + 1},${i + 2}`);
+        const breachOnly = !hasReturn && (actionIsTransmit(low.action) || actionIsTransmit(high.action));
+        alerts.push({
+            type: 'range',
+            channel: ch,
+            lowC,
+            highC,
+            hysteresisC: hyst,
+            transmitOnBreach: hasReturn || breachOnly,
+            transmitOnReturn: hasReturn,
+        });
+        used[i] = true;
+        used[i + 1] = true;
+        if (hasReturn) {
+            for (let j = 0; j < 12; j++) {
+                const r = padded[j];
+                if (r.condition !== CONDITION_LOGIC && !r.condition.includes('LOGIC'))
+                    continue;
+                if (!logicIsOr(r.parameters))
+                    continue;
+                const ids = selectedRuleIds(r.parameters[1] ?? 0);
+                if (ids.length === 2 && ids[0] === i + 1 && ids[1] === i + 2) {
+                    used[j] = true;
+                    break;
+                }
+            }
+        }
+    }
+    for (let i = 0; i < 12; i++) {
+        if (used[i])
+            continue;
+        const r = padded[i];
+        const ch = channelFromMask(r.channel_mask);
+        if (!ch)
+            continue;
+        const hyst = wireTempToC(r.parameters[1] ?? 10);
+        if (r.condition === CONDITION_LOW || r.condition.includes('LOW_THRESHOLD')) {
+            alerts.push({
+                type: 'min',
+                channel: ch,
+                minC: wireTempToC(r.parameters[0] ?? 0),
+                hysteresisC: hyst,
+                transmitOnBreach: actionIsTransmit(r.action),
+            });
+            used[i] = true;
+        }
+        else if (r.condition === CONDITION_HIGH || r.condition.includes('HIGH_THRESHOLD')) {
+            alerts.push({
+                type: 'max',
+                channel: ch,
+                maxC: wireTempToC(r.parameters[0] ?? 0),
+                hysteresisC: hyst,
+                transmitOnBreach: actionIsTransmit(r.action),
+            });
+            used[i] = true;
+        }
+    }
+    const out = {
+        temperatureAlerts: alerts,
+        schedule: { always: true },
+    };
+    const measBase = asNum(cfg.measurement_period_base ?? cfg.measurementPeriodBase);
+    const measFactor = asNum(cfg.measurement_period_factor ?? cfg.measurementPeriodFactor) ?? 1;
+    if (measBase != null && measBase > 0) {
+        const factor = measFactor === 0 ? 1 : measFactor;
+        out.measurementIntervalMinutes = (measBase * factor) / 60;
+    }
+    const tx = asNum(cfg.transmission_interval ?? cfg.transmissionInterval);
+    if (tx != null && tx > 0)
+        out.transmissionIntervalSeconds = tx;
+    return out;
+}
+export function partnerConfigFromProtoBase64(b64) {
+    return partnerConfigFromProtoObject(decodeProtoConfigBase64(b64));
+}

package/dist/proto/partner-to-proto.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Partner temperatureAlerts + schedule + intervals → ProtoConfig bytes.
+ * Mirrors scripts/efento-local-mac/partner_rules.py (interleaved L/H/OR).
+ */
+import type { TempivoSensorConfiguration } from '../session-types.js';
+import { type ProtoConfigObject } from './decode-proto-config.js';
+/** Patch partner alerts/schedule/intervals onto a baseline ProtoConfig object. */
+export declare function applyPartnerConfigToProtoObject(baseline: ProtoConfigObject, partner: TempivoSensorConfiguration): ProtoConfigObject;
+export declare function encodeProtoConfigObject(cfg: ProtoConfigObject): Uint8Array;
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/** Apply partner config onto baseline ProtoConfig base64 → new base64. */
+export declare function partnerConfigToProtoBase64(partner: TempivoSensorConfiguration, baselineProtoBase64: string): string;

package/dist/proto/partner-to-proto.js

@@ -0,0 +1,211 @@
+import { decodeProtoConfigBase64 } from './decode-proto-config.js';
+import protobuf from 'protobufjs/light.js';
+import descriptor from './efento-protobuf-descriptor.js';
+const root = protobuf.Root.fromJSON(descriptor);
+const ProtoConfig = root.lookupType('ProtoConfig');
+const CONDITION_DISABLED = 1;
+const CONDITION_HIGH = 2;
+const CONDITION_LOW = 3;
+const CONDITION_LOGIC = 6;
+const LOGIC_OR = 2;
+const ACTION_NO_ACTION = 2;
+const ACTION_TRIGGER_ACK = 3;
+const CALENDAR_DISABLED = 1;
+const CALENDAR_WEEK = 2;
+const MEASUREMENT_TEMP = 1;
+const TRIGGER_CONSECUTIVE = 3;
+function tempToWire(c) {
+    return Math.round(c * 10);
+}
+function channelMask(channel) {
+    return 1 << (channel - 1);
+}
+function ruleBitmask(ids) {
+    let mask = 0;
+    for (const id of ids)
+        mask |= 1 << (id - 1);
+    return mask;
+}
+function disabledRule() {
+    return {
+        channelMask: 0,
+        condition: CONDITION_DISABLED,
+        action: ACTION_NO_ACTION,
+        parameters: [],
+    };
+}
+function thresholdRule(opts) {
+    return {
+        channelMask: channelMask(opts.channel),
+        condition: opts.low ? CONDITION_LOW : CONDITION_HIGH,
+        action: opts.action,
+        parameters: [
+            tempToWire(opts.thresholdC),
+            tempToWire(opts.hysteresisC),
+            TRIGGER_CONSECUTIVE,
+            1,
+            MEASUREMENT_TEMP,
+        ],
+    };
+}
+function orReturnRule(lowSlot) {
+    return {
+        channelMask: 0,
+        condition: CONDITION_LOGIC,
+        action: ACTION_TRIGGER_ACK,
+        parameters: [LOGIC_OR, ruleBitmask([lowSlot + 1, lowSlot + 2]), 0, 0, 0],
+    };
+}
+function compileAlerts(alerts) {
+    const rules = Array.from({ length: 12 }, () => disabledRule());
+    const used = new Array(12).fill(false);
+    const findPair = () => {
+        for (let i = 0; i < 11; i++)
+            if (!used[i] && !used[i + 1])
+                return i;
+        return null;
+    };
+    const findFree = () => {
+        for (let i = 0; i < 12; i++)
+            if (!used[i])
+                return i;
+        return null;
+    };
+    for (const alert of alerts) {
+        const channel = alert.channel === 'probe' ? 3 : 1;
+        const hyst = alert.hysteresisC ?? 1;
+        if (alert.type === 'range') {
+            const pair = findPair();
+            if (pair == null)
+                throw new Error('Not enough free alarm rule slots for another range.');
+            const ret = Boolean(alert.transmitOnReturn);
+            const action = ret
+                ? ACTION_NO_ACTION
+                : alert.transmitOnBreach
+                    ? ACTION_TRIGGER_ACK
+                    : ACTION_NO_ACTION;
+            rules[pair] = thresholdRule({
+                channel,
+                low: true,
+                thresholdC: alert.lowC,
+                hysteresisC: hyst,
+                action,
+            });
+            rules[pair + 1] = thresholdRule({
+                channel,
+                low: false,
+                thresholdC: alert.highC,
+                hysteresisC: hyst,
+                action,
+            });
+            used[pair] = used[pair + 1] = true;
+            if (ret) {
+                const logic = findFree();
+                if (logic == null)
+                    throw new Error('Not enough free slots for transmit-on-return OR.');
+                rules[logic] = orReturnRule(pair);
+                used[logic] = true;
+            }
+        }
+        else if (alert.type === 'min' || alert.type === 'max') {
+            const slot = findFree();
+            if (slot == null)
+                throw new Error('Not enough free alarm rule slots.');
+            const action = alert.transmitOnBreach ? ACTION_TRIGGER_ACK : ACTION_NO_ACTION;
+            const thresholdC = alert.type === 'min' ? alert.minC : alert.maxC;
+            rules[slot] = thresholdRule({
+                channel,
+                low: alert.type === 'min',
+                thresholdC,
+                hysteresisC: hyst,
+                action,
+            });
+            used[slot] = true;
+        }
+        else {
+            throw new Error(`Unsupported temperature alert type: ${alert.type}`);
+        }
+    }
+    const mask = ruleBitmask(used.map((u, i) => (u ? i + 1 : 0)).filter((id) => id > 0));
+    return { rules, mask };
+}
+function alwaysCalendar(ruleMask) {
+    return {
+        ruleMask,
+        type: CALENDAR_WEEK,
+        parameters: [0x7f, 0, 1439, 0],
+    };
+}
+function disabledCalendars() {
+    return Array.from({ length: 6 }, () => ({
+        type: CALENDAR_DISABLED,
+        ruleMask: 0,
+        parameters: [],
+    }));
+}
+/**
+ * Fields carried from the device baseline into a set (0x0D).
+ *
+ * A device read returns the full config, including server endpoints, APN, cloud token and
+ * telemetry. Echoing all of that back exceeds the single-write ATT limit (~512 B) and would
+ * rewrite cellular settings we never intended to touch, so only rules-related fields are kept.
+ */
+const WRITE_BASELINE_FIELDS = [
+    'serialNumber',
+    'channelTypes',
+    'measurementPeriodBase',
+    'measurementPeriodFactor',
+    'transmissionInterval',
+];
+/** Patch partner alerts/schedule/intervals onto a baseline ProtoConfig object. */
+export function applyPartnerConfigToProtoObject(baseline, partner) {
+    const { rules, mask } = compileAlerts(partner.temperatureAlerts ?? []);
+    const out = { rules };
+    for (const field of WRITE_BASELINE_FIELDS) {
+        if (baseline[field] !== undefined && baseline[field] !== null)
+            out[field] = baseline[field];
+    }
+    const cals = disabledCalendars();
+    const always = partner.schedule == null ||
+        ('always' in partner.schedule && partner.schedule.always === true) ||
+        !('weekdays' in partner.schedule);
+    if (mask && always)
+        cals[0] = alwaysCalendar(mask);
+    out.calendars = cals;
+    if (partner.measurementIntervalMinutes != null && partner.measurementIntervalMinutes > 0) {
+        out.measurementPeriodBase = Math.round(partner.measurementIntervalMinutes * 60);
+        out.measurementPeriodFactor = 1;
+    }
+    if (partner.transmissionIntervalSeconds != null && partner.transmissionIntervalSeconds > 0) {
+        out.transmissionInterval = partner.transmissionIntervalSeconds;
+    }
+    return out;
+}
+export function encodeProtoConfigObject(cfg) {
+    // Baseline from decode uses enums: String; fromObject maps names → wire ints.
+    const msg = ProtoConfig.fromObject(cfg);
+    const err = ProtoConfig.verify(msg);
+    if (err)
+        throw new Error(err);
+    return ProtoConfig.encode(msg).finish();
+}
+export function bytesToBase64(bytes) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    let out = '';
+    for (let i = 0; i < bytes.length; i += 3) {
+        const a = bytes[i];
+        const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+        const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+        out += chars[a >> 2];
+        out += chars[((a & 3) << 4) | (b >> 4)];
+        out += i + 1 < bytes.length ? chars[((b & 15) << 2) | (c >> 6)] : '=';
+        out += i + 2 < bytes.length ? chars[c & 63] : '=';
+    }
+    return out;
+}
+/** Apply partner config onto baseline ProtoConfig base64 → new base64. */
+export function partnerConfigToProtoBase64(partner, baselineProtoBase64) {
+    const baseline = decodeProtoConfigBase64(baselineProtoBase64);
+    const next = applyPartnerConfigToProtoObject(baseline, partner);
+    return bytesToBase64(encodeProtoConfigObject(next));
+}