edilkamin 1.10.0 → 1.10.1

package/dist/esm/src/library.test.js

@@ -215,6 +215,17 @@ describe("library", () => {
             "getLanguage",
             "getPelletInReserve",
             "getPelletAutonomyTime",
+            // Statistics getters
+            "getTotalCounters",
+            "getServiceCounters",
+            "getAlarmHistory",
+            "getRegenerationData",
+            "getServiceTime",
+            // Analytics functions
+            "getTotalOperatingHours",
+            "getPowerDistribution",
+            "getServiceStatus",
+            "getUsageAnalytics",
         ];
         it("should create API methods with the correct baseURL", () => __awaiter(void 0, void 0, void 0, function* () {
             const baseURL = "https://example.com/api/";
@@ -786,6 +797,218 @@ describe("library", () => {
             assert.equal(result, 240);
         }));
     });
+    describe("statistics getters", () => {
+        const mockDeviceInfoWithStats = {
+            status: {
+                commands: { power: true },
+                temperatures: { board: 25, enviroment: 20 },
+                flags: { is_pellet_in_reserve: false },
+                pellet: { autonomy_time: 900 },
+                counters: { service_time: 1108 },
+            },
+            nvm: {
+                user_parameters: {
+                    language: 1,
+                    is_auto: false,
+                    is_fahrenheit: false,
+                    is_sound_active: false,
+                    enviroment_1_temperature: 19,
+                    enviroment_2_temperature: 20,
+                    enviroment_3_temperature: 20,
+                    manual_power: 1,
+                    fan_1_ventilation: 3,
+                    fan_2_ventilation: 0,
+                    fan_3_ventilation: 0,
+                    is_standby_active: false,
+                    standby_waiting_time: 60,
+                },
+                total_counters: {
+                    power_ons: 278,
+                    p1_working_time: 833,
+                    p2_working_time: 15,
+                    p3_working_time: 19,
+                    p4_working_time: 8,
+                    p5_working_time: 17,
+                },
+                service_counters: {
+                    p1_working_time: 100,
+                    p2_working_time: 10,
+                    p3_working_time: 5,
+                    p4_working_time: 2,
+                    p5_working_time: 1,
+                },
+                alarms_log: {
+                    number: 2,
+                    index: 2,
+                    alarms: [
+                        { type: 3, timestamp: 1700000000 },
+                        { type: 21, timestamp: 1700001000 },
+                    ],
+                },
+                regeneration: {
+                    time: 0,
+                    last_intervention: 1577836800,
+                    daylight_time_flag: 0,
+                    blackout_counter: 43,
+                    airkare_working_hours_counter: 0,
+                },
+            },
+        };
+        it("should get total counters", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfoWithStats));
+            const api = configure(API_URL);
+            const result = yield api.getTotalCounters(expectedToken, "00:11:22:33:44:55");
+            assert.deepEqual(result, mockDeviceInfoWithStats.nvm.total_counters);
+        }));
+        it("should get service counters", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfoWithStats));
+            const api = configure(API_URL);
+            const result = yield api.getServiceCounters(expectedToken, "00:11:22:33:44:55");
+            assert.deepEqual(result, mockDeviceInfoWithStats.nvm.service_counters);
+        }));
+        it("should get alarm history", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfoWithStats));
+            const api = configure(API_URL);
+            const result = yield api.getAlarmHistory(expectedToken, "00:11:22:33:44:55");
+            assert.deepEqual(result, mockDeviceInfoWithStats.nvm.alarms_log);
+        }));
+        it("should get regeneration data", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfoWithStats));
+            const api = configure(API_URL);
+            const result = yield api.getRegenerationData(expectedToken, "00:11:22:33:44:55");
+            assert.deepEqual(result, mockDeviceInfoWithStats.nvm.regeneration);
+        }));
+        it("should get service time", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfoWithStats));
+            const api = configure(API_URL);
+            const result = yield api.getServiceTime(expectedToken, "00:11:22:33:44:55");
+            assert.equal(result, 1108);
+        }));
+    });
+    describe("analytics functions", () => {
+        const mockDeviceInfoWithStats = {
+            status: {
+                commands: { power: true },
+                temperatures: { board: 25, enviroment: 20 },
+                flags: { is_pellet_in_reserve: false },
+                pellet: { autonomy_time: 900 },
+                counters: { service_time: 1108 },
+            },
+            nvm: {
+                user_parameters: {
+                    language: 1,
+                    is_auto: false,
+                    is_fahrenheit: false,
+                    is_sound_active: false,
+                    enviroment_1_temperature: 19,
+                    enviroment_2_temperature: 20,
+                    enviroment_3_temperature: 20,
+                    manual_power: 1,
+                    fan_1_ventilation: 3,
+                    fan_2_ventilation: 0,
+                    fan_3_ventilation: 0,
+                    is_standby_active: false,
+                    standby_waiting_time: 60,
+                },
+                total_counters: {
+                    power_ons: 278,
+                    p1_working_time: 833,
+                    p2_working_time: 15,
+                    p3_working_time: 19,
+                    p4_working_time: 8,
+                    p5_working_time: 17,
+                },
+                service_counters: {
+                    p1_working_time: 100,
+                    p2_working_time: 10,
+                    p3_working_time: 5,
+                    p4_working_time: 2,
+                    p5_working_time: 1,
+                },
+                alarms_log: {
+                    number: 2,
+                    index: 2,
+                    alarms: [
+                        { type: 3, timestamp: 1700000000 },
+                        { type: 21, timestamp: 1700001000 },
+                    ],
+                },
+                regeneration: {
+                    time: 0,
+                    last_intervention: 1577836800,
+                    daylight_time_flag: 0,
+                    blackout_counter: 43,
+                    airkare_working_hours_counter: 0,
+                },
+            },
+        };
+        it("should calculate total operating hours", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfoWithStats));
+            const api = configure(API_URL);
+            const result = yield api.getTotalOperatingHours(expectedToken, "00:11:22:33:44:55");
+            // 833 + 15 + 19 + 8 + 17 = 892
+            assert.equal(result, 892);
+        }));
+        it("should calculate power distribution percentages", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfoWithStats));
+            const api = configure(API_URL);
+            const result = yield api.getPowerDistribution(expectedToken, "00:11:22:33:44:55");
+            // Total: 892 hours
+            assert.ok(result.p1 > 90); // 833/892 = 93.4%
+            assert.ok(result.p2 < 5); // 15/892 = 1.7%
+            // Sum should be ~100%
+            const sum = result.p1 + result.p2 + result.p3 + result.p4 + result.p5;
+            assert.ok(Math.abs(sum - 100) < 0.1);
+        }));
+        it("should handle zero operating hours in power distribution", () => __awaiter(void 0, void 0, void 0, function* () {
+            const zeroHoursInfo = Object.assign(Object.assign({}, mockDeviceInfoWithStats), { nvm: Object.assign(Object.assign({}, mockDeviceInfoWithStats.nvm), { total_counters: {
+                        power_ons: 0,
+                        p1_working_time: 0,
+                        p2_working_time: 0,
+                        p3_working_time: 0,
+                        p4_working_time: 0,
+                        p5_working_time: 0,
+                    } }) });
+            fetchStub.resolves(mockResponse(zeroHoursInfo));
+            const api = configure(API_URL);
+            const result = yield api.getPowerDistribution(expectedToken, "00:11:22:33:44:55");
+            assert.deepEqual(result, { p1: 0, p2: 0, p3: 0, p4: 0, p5: 0 });
+        }));
+        it("should calculate service status", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfoWithStats));
+            const api = configure(API_URL);
+            const result = yield api.getServiceStatus(expectedToken, "00:11:22:33:44:55");
+            assert.equal(result.totalServiceHours, 1108);
+            // 100 + 10 + 5 + 2 + 1 = 118 hours since service
+            assert.equal(result.hoursSinceService, 118);
+            assert.equal(result.isServiceDue, false); // 118 < 2000
+        }));
+        it("should indicate service is due when threshold exceeded", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfoWithStats));
+            const api = configure(API_URL);
+            // Use threshold of 100 hours
+            const result = yield api.getServiceStatus(expectedToken, "00:11:22:33:44:55", 100);
+            assert.equal(result.isServiceDue, true); // 118 >= 100
+        }));
+        it("should get comprehensive usage analytics", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfoWithStats));
+            const api = configure(API_URL);
+            const result = yield api.getUsageAnalytics(expectedToken, "00:11:22:33:44:55");
+            assert.equal(result.totalPowerOns, 278);
+            assert.equal(result.totalOperatingHours, 892);
+            assert.equal(result.blackoutCount, 43);
+            assert.equal(result.alarmCount, 2);
+            assert.ok(result.lastMaintenanceDate instanceof Date);
+            assert.equal(result.serviceStatus.isServiceDue, false);
+        }));
+        it("should handle null lastMaintenanceDate when timestamp is 0", () => __awaiter(void 0, void 0, void 0, function* () {
+            const noMaintenanceInfo = Object.assign(Object.assign({}, mockDeviceInfoWithStats), { nvm: Object.assign(Object.assign({}, mockDeviceInfoWithStats.nvm), { regeneration: Object.assign(Object.assign({}, mockDeviceInfoWithStats.nvm.regeneration), { last_intervention: 0 }) }) });
+            fetchStub.resolves(mockResponse(noMaintenanceInfo));
+            const api = configure(API_URL);
+            const result = yield api.getUsageAnalytics(expectedToken, "00:11:22:33:44:55");
+            assert.equal(result.lastMaintenanceDate, null);
+        }));
+    });
     describe("Error Handling", () => {
         const errorTests = [
             { status: 400, statusText: "Bad Request" },

package/dist/esm/src/types.d.ts

@@ -19,11 +19,18 @@ interface GeneralFlagsType {
 interface PelletAutonomyType {
     autonomy_time: number;
 }
+/**
+ * Status counters including service time.
+ */
+interface StatusCountersType {
+    service_time: number;
+}
 interface StatusType {
     commands: CommandsType;
     temperatures: TemperaturesType;
     flags: GeneralFlagsType;
     pellet: PelletAutonomyType;
+    counters: StatusCountersType;
 }
 interface UserParametersType {
     enviroment_1_temperature: number;
@@ -40,10 +47,128 @@ interface UserParametersType {
     is_fahrenheit: boolean;
     language: number;
 }
+/**
+ * Lifetime operating counters - never reset.
+ * Tracks total power-on cycles and runtime hours per power level.
+ */
+interface TotalCountersType {
+    power_ons: number;
+    p1_working_time: number;
+    p2_working_time: number;
+    p3_working_time: number;
+    p4_working_time: number;
+    p5_working_time: number;
+}
+/**
+ * Service counters - reset after maintenance.
+ * Tracks runtime hours per power level since last service.
+ */
+interface ServiceCountersType {
+    p1_working_time: number;
+    p2_working_time: number;
+    p3_working_time: number;
+    p4_working_time: number;
+    p5_working_time: number;
+}
+/**
+ * Individual alarm entry from the alarm history log.
+ */
+interface AlarmEntryType {
+    type: number;
+    timestamp: number;
+}
+/**
+ * Alarm history log - circular buffer of recent alarms.
+ */
+interface AlarmsLogType {
+    number: number;
+    index: number;
+    alarms: AlarmEntryType[];
+}
+/**
+ * Regeneration and maintenance tracking data.
+ */
+interface RegenerationDataType {
+    time: number;
+    last_intervention: number;
+    daylight_time_flag: number;
+    blackout_counter: number;
+    airkare_working_hours_counter: number;
+}
+/**
+ * Power level distribution as percentages.
+ */
+interface PowerDistributionType {
+    p1: number;
+    p2: number;
+    p3: number;
+    p4: number;
+    p5: number;
+}
+/**
+ * Service status with computed fields.
+ */
+interface ServiceStatusType {
+    totalServiceHours: number;
+    hoursSinceService: number;
+    serviceThresholdHours: number;
+    isServiceDue: boolean;
+}
+/**
+ * Comprehensive usage analytics.
+ */
+interface UsageAnalyticsType {
+    totalPowerOns: number;
+    totalOperatingHours: number;
+    powerDistribution: PowerDistributionType;
+    serviceStatus: ServiceStatusType;
+    blackoutCount: number;
+    lastMaintenanceDate: Date | null;
+    alarmCount: number;
+}
+/**
+ * Alarm type codes from Edilkamin devices.
+ * Based on AlarmsEnum.java from Android app (version 1.3.1-RC2 released 2025/12/10).
+ */
+declare enum AlarmCode {
+    NONE = 0,
+    FLUE_BLOCK = 1,
+    SMOKE_EXTRACTOR_FAILURE = 2,
+    END_PELLET = 3,
+    MISSING_LIGHTING = 4,
+    NO_NAME_ALARM = 5,
+    SMOKE_PROBE_FAILURE = 6,
+    FUMES_OVERTEMPERATURE = 7,
+    PELLET_TANK_SAFETY_THERMOSTAT = 8,
+    GEAR_MOTOR_FAILURE = 9,
+    BOARD_OVER_TEMPERATURE = 10,
+    SAFETY_PRESSURE_SWITCH_INTERVENTION = 11,
+    ROOM_PROBE_FAILURE = 12,
+    ROOM_PROBE_2_OR_BOILER_PROBE_FAILURE = 13,
+    ROOM_PROBE_3_OR_BOILER_PROBE_FAILURE = 14,
+    WATER_EARTHQUAKE_SAFETY_THERMOSTAT_INTERVENTION = 15,
+    WATER_PRESSURE_TRANSDUCER_FAILURE = 16,
+    OUTSIDE_PROBE_OR_LOW_STORAGE_PROBE_FAILURE = 17,
+    PUFFER_PROBE_FAILURE = 18,
+    CRUCIBLE_CLEANING_FAILURE = 19,
+    TRIAC_FAILURE = 20,
+    BLACKOUT = 21,
+    OPEN_DOOR = 22,
+    OVERTEMPERATURE_PANEL = 23,
+    BOARD_FUSE = 24
+}
+/**
+ * Human-readable descriptions for alarm codes.
+ */
+declare const AlarmDescriptions: Record<AlarmCode, string>;
 interface DeviceInfoType {
     status: StatusType;
     nvm: {
         user_parameters: UserParametersType;
+        total_counters: TotalCountersType;
+        service_counters: ServiceCountersType;
+        alarms_log: AlarmsLogType;
+        regeneration: RegenerationDataType;
     };
 }
 /**
@@ -99,4 +224,5 @@ interface DiscoveredDevice {
     /** Signal strength in dBm (optional, not all platforms provide this) */
     rssi?: number;
 }
-export type { BufferEncodedType, CommandsType, DeviceAssociationBody, DeviceAssociationResponse, DeviceInfoRawType, DeviceInfoType, DiscoveredDevice, EditDeviceAssociationBody, GeneralFlagsType, PelletAutonomyType, StatusType, TemperaturesType, UserParametersType, };
+export type { AlarmEntryType, AlarmsLogType, BufferEncodedType, CommandsType, DeviceAssociationBody, DeviceAssociationResponse, DeviceInfoRawType, DeviceInfoType, DiscoveredDevice, EditDeviceAssociationBody, GeneralFlagsType, PelletAutonomyType, PowerDistributionType, RegenerationDataType, ServiceCountersType, ServiceStatusType, StatusCountersType, StatusType, TemperaturesType, TotalCountersType, UsageAnalyticsType, UserParametersType, };
+export { AlarmCode, AlarmDescriptions };

package/dist/esm/src/types.js

@@ -1 +1,63 @@
-export {};
+/**
+ * Alarm type codes from Edilkamin devices.
+ * Based on AlarmsEnum.java from Android app (version 1.3.1-RC2 released 2025/12/10).
+ */
+var AlarmCode;
+(function (AlarmCode) {
+    AlarmCode[AlarmCode["NONE"] = 0] = "NONE";
+    AlarmCode[AlarmCode["FLUE_BLOCK"] = 1] = "FLUE_BLOCK";
+    AlarmCode[AlarmCode["SMOKE_EXTRACTOR_FAILURE"] = 2] = "SMOKE_EXTRACTOR_FAILURE";
+    AlarmCode[AlarmCode["END_PELLET"] = 3] = "END_PELLET";
+    AlarmCode[AlarmCode["MISSING_LIGHTING"] = 4] = "MISSING_LIGHTING";
+    AlarmCode[AlarmCode["NO_NAME_ALARM"] = 5] = "NO_NAME_ALARM";
+    AlarmCode[AlarmCode["SMOKE_PROBE_FAILURE"] = 6] = "SMOKE_PROBE_FAILURE";
+    AlarmCode[AlarmCode["FUMES_OVERTEMPERATURE"] = 7] = "FUMES_OVERTEMPERATURE";
+    AlarmCode[AlarmCode["PELLET_TANK_SAFETY_THERMOSTAT"] = 8] = "PELLET_TANK_SAFETY_THERMOSTAT";
+    AlarmCode[AlarmCode["GEAR_MOTOR_FAILURE"] = 9] = "GEAR_MOTOR_FAILURE";
+    AlarmCode[AlarmCode["BOARD_OVER_TEMPERATURE"] = 10] = "BOARD_OVER_TEMPERATURE";
+    AlarmCode[AlarmCode["SAFETY_PRESSURE_SWITCH_INTERVENTION"] = 11] = "SAFETY_PRESSURE_SWITCH_INTERVENTION";
+    AlarmCode[AlarmCode["ROOM_PROBE_FAILURE"] = 12] = "ROOM_PROBE_FAILURE";
+    AlarmCode[AlarmCode["ROOM_PROBE_2_OR_BOILER_PROBE_FAILURE"] = 13] = "ROOM_PROBE_2_OR_BOILER_PROBE_FAILURE";
+    AlarmCode[AlarmCode["ROOM_PROBE_3_OR_BOILER_PROBE_FAILURE"] = 14] = "ROOM_PROBE_3_OR_BOILER_PROBE_FAILURE";
+    AlarmCode[AlarmCode["WATER_EARTHQUAKE_SAFETY_THERMOSTAT_INTERVENTION"] = 15] = "WATER_EARTHQUAKE_SAFETY_THERMOSTAT_INTERVENTION";
+    AlarmCode[AlarmCode["WATER_PRESSURE_TRANSDUCER_FAILURE"] = 16] = "WATER_PRESSURE_TRANSDUCER_FAILURE";
+    AlarmCode[AlarmCode["OUTSIDE_PROBE_OR_LOW_STORAGE_PROBE_FAILURE"] = 17] = "OUTSIDE_PROBE_OR_LOW_STORAGE_PROBE_FAILURE";
+    AlarmCode[AlarmCode["PUFFER_PROBE_FAILURE"] = 18] = "PUFFER_PROBE_FAILURE";
+    AlarmCode[AlarmCode["CRUCIBLE_CLEANING_FAILURE"] = 19] = "CRUCIBLE_CLEANING_FAILURE";
+    AlarmCode[AlarmCode["TRIAC_FAILURE"] = 20] = "TRIAC_FAILURE";
+    AlarmCode[AlarmCode["BLACKOUT"] = 21] = "BLACKOUT";
+    AlarmCode[AlarmCode["OPEN_DOOR"] = 22] = "OPEN_DOOR";
+    AlarmCode[AlarmCode["OVERTEMPERATURE_PANEL"] = 23] = "OVERTEMPERATURE_PANEL";
+    AlarmCode[AlarmCode["BOARD_FUSE"] = 24] = "BOARD_FUSE";
+})(AlarmCode || (AlarmCode = {}));
+/**
+ * Human-readable descriptions for alarm codes.
+ */
+const AlarmDescriptions = {
+    [AlarmCode.NONE]: "No alarm",
+    [AlarmCode.FLUE_BLOCK]: "Flue/chimney blockage",
+    [AlarmCode.SMOKE_EXTRACTOR_FAILURE]: "Smoke extractor motor failure",
+    [AlarmCode.END_PELLET]: "Pellet tank empty",
+    [AlarmCode.MISSING_LIGHTING]: "Ignition failure",
+    [AlarmCode.NO_NAME_ALARM]: "Unnamed alarm",
+    [AlarmCode.SMOKE_PROBE_FAILURE]: "Smoke temperature probe failure",
+    [AlarmCode.FUMES_OVERTEMPERATURE]: "Exhaust overtemperature",
+    [AlarmCode.PELLET_TANK_SAFETY_THERMOSTAT]: "Pellet tank safety thermostat triggered",
+    [AlarmCode.GEAR_MOTOR_FAILURE]: "Gear motor/auger failure",
+    [AlarmCode.BOARD_OVER_TEMPERATURE]: "Control board overtemperature",
+    [AlarmCode.SAFETY_PRESSURE_SWITCH_INTERVENTION]: "Safety pressure switch activated",
+    [AlarmCode.ROOM_PROBE_FAILURE]: "Room temperature probe failure",
+    [AlarmCode.ROOM_PROBE_2_OR_BOILER_PROBE_FAILURE]: "Room probe 2 or boiler probe failure",
+    [AlarmCode.ROOM_PROBE_3_OR_BOILER_PROBE_FAILURE]: "Room probe 3 or boiler probe failure",
+    [AlarmCode.WATER_EARTHQUAKE_SAFETY_THERMOSTAT_INTERVENTION]: "Water/earthquake safety thermostat",
+    [AlarmCode.WATER_PRESSURE_TRANSDUCER_FAILURE]: "Water pressure transducer failure",
+    [AlarmCode.OUTSIDE_PROBE_OR_LOW_STORAGE_PROBE_FAILURE]: "Outside probe or low storage probe failure",
+    [AlarmCode.PUFFER_PROBE_FAILURE]: "Buffer tank probe failure",
+    [AlarmCode.CRUCIBLE_CLEANING_FAILURE]: "Crucible cleaning failure",
+    [AlarmCode.TRIAC_FAILURE]: "Power control (TRIAC) failure",
+    [AlarmCode.BLACKOUT]: "Power outage detected",
+    [AlarmCode.OPEN_DOOR]: "Door open alarm",
+    [AlarmCode.OVERTEMPERATURE_PANEL]: "Panel overtemperature",
+    [AlarmCode.BOARD_FUSE]: "Control board fuse issue",
+};
+export { AlarmCode, AlarmDescriptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edilkamin",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "description": "",
   "main": "dist/cjs/src/index.js",
   "module": "dist/esm/src/index.js",

package/src/cli.ts

@@ -6,6 +6,7 @@ import { version } from "../package.json";
 import { NEW_API_URL, OLD_API_URL } from "./constants";
 import { configure, configureAmplify, getSession, signIn } from "./library";
 import { clearSession, createFileStorage } from "./token-storage";
+import { AlarmCode, AlarmDescriptions } from "./types";
 
 const promptPassword = (): Promise<string> => {
   const rl = readline.createInterface({
@@ -336,6 +337,117 @@ const createProgram = (): Command => {
         mac: string,
       ) => api.getPelletAutonomyTime(jwtToken, mac),
     },
+    // Statistics getters
+    {
+      commandName: "getTotalCounters",
+      description:
+        "Get lifetime operating counters (power-ons, runtime by power level)",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getTotalCounters(jwtToken, mac),
+    },
+    {
+      commandName: "getServiceCounters",
+      description: "Get service counters (runtime since last maintenance)",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getServiceCounters(jwtToken, mac),
+    },
+    {
+      commandName: "getRegenerationData",
+      description: "Get regeneration and maintenance data",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getRegenerationData(jwtToken, mac),
+    },
+    {
+      commandName: "getServiceTime",
+      description: "Get total service time in hours",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getServiceTime(jwtToken, mac),
+    },
+    // Analytics getters
+    {
+      commandName: "getTotalOperatingHours",
+      description: "Get total operating hours across all power levels",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getTotalOperatingHours(jwtToken, mac),
+    },
+    {
+      commandName: "getPowerDistribution",
+      description: "Get power level usage distribution as percentages",
+      getter: async (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => {
+        const result = await api.getPowerDistribution(jwtToken, mac);
+        return {
+          p1: `${result.p1.toFixed(1)}%`,
+          p2: `${result.p2.toFixed(1)}%`,
+          p3: `${result.p3.toFixed(1)}%`,
+          p4: `${result.p4.toFixed(1)}%`,
+          p5: `${result.p5.toFixed(1)}%`,
+        };
+      },
+    },
+    {
+      commandName: "getServiceStatus",
+      description: "Get service status including whether maintenance is due",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getServiceStatus(jwtToken, mac),
+    },
+    {
+      commandName: "getUsageAnalytics",
+      description: "Get comprehensive usage analytics in single response",
+      getter: async (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => {
+        const analytics = await api.getUsageAnalytics(jwtToken, mac);
+        return {
+          lifetime: {
+            powerOnCount: analytics.totalPowerOns,
+            totalOperatingHours: analytics.totalOperatingHours,
+            blackoutCount: analytics.blackoutCount,
+          },
+          powerDistribution: {
+            p1: `${analytics.powerDistribution.p1.toFixed(1)}%`,
+            p2: `${analytics.powerDistribution.p2.toFixed(1)}%`,
+            p3: `${analytics.powerDistribution.p3.toFixed(1)}%`,
+            p4: `${analytics.powerDistribution.p4.toFixed(1)}%`,
+            p5: `${analytics.powerDistribution.p5.toFixed(1)}%`,
+          },
+          service: {
+            totalServiceHours: analytics.serviceStatus.totalServiceHours,
+            hoursSinceLastService: analytics.serviceStatus.hoursSinceService,
+            thresholdHours: analytics.serviceStatus.serviceThresholdHours,
+            isServiceDue: analytics.serviceStatus.isServiceDue,
+            lastMaintenanceDate:
+              analytics.lastMaintenanceDate?.toISOString() || "Never",
+          },
+          alarms: {
+            totalCount: analytics.alarmCount,
+          },
+        };
+      },
+    },
   ].forEach(({ commandName, description, getter }) => {
     addLegacyOption(
       addMacOption(
@@ -676,6 +788,50 @@ const createProgram = (): Command => {
     console.log(JSON.stringify(result, null, 2));
   });
 
+  // Alarm history command with human-readable descriptions
+  addLegacyOption(
+    addMacOption(
+      addAuthOptions(
+        program
+          .command("getAlarmHistory")
+          .description(
+            "Get alarm history log with human-readable descriptions",
+          ),
+      ),
+    ),
+  ).action(async (options) => {
+    const { username, password, mac, legacy = false } = options;
+    const normalizedMac = mac.replace(/:/g, "");
+    const storage = createFileStorage();
+    configureAmplify(storage);
+    let jwtToken: string;
+    try {
+      jwtToken = await getSession(false, legacy);
+    } catch {
+      if (!username) {
+        throw new Error(
+          "No session found. Please provide --username to sign in.",
+        );
+      }
+      const pwd = password || (await promptPassword());
+      jwtToken = await signIn(username, pwd, legacy);
+    }
+    const apiUrl = legacy ? OLD_API_URL : NEW_API_URL;
+    const api = configure(apiUrl);
+    const result = await api.getAlarmHistory(jwtToken, normalizedMac);
+    // Format alarms with human-readable descriptions
+    const formattedAlarms = result.alarms.map((alarm) => ({
+      ...alarm,
+      typeName: AlarmCode[alarm.type] || "UNKNOWN",
+      description:
+        AlarmDescriptions[alarm.type as AlarmCode] || "Unknown alarm",
+      date: new Date(alarm.timestamp * 1000).toISOString(),
+    }));
+    console.log(
+      JSON.stringify({ ...result, alarms: formattedAlarms }, null, 2),
+    );
+  });
+
   // Command: register
   addLegacyOption(
     addAuthOptions(

package/src/index.ts

@@ -10,6 +10,8 @@ export {
   serialNumberToHex,
 } from "./serial-utils";
 export {
+  AlarmEntryType,
+  AlarmsLogType,
   BufferEncodedType,
   CommandsType,
   DeviceAssociationBody,
@@ -18,10 +20,18 @@ export {
   DeviceInfoType,
   DiscoveredDevice,
   EditDeviceAssociationBody,
+  PowerDistributionType,
+  RegenerationDataType,
+  ServiceCountersType,
+  ServiceStatusType,
+  StatusCountersType,
   StatusType,
   TemperaturesType,
+  TotalCountersType,
+  UsageAnalyticsType,
   UserParametersType,
 } from "./types";
+export { AlarmCode, AlarmDescriptions } from "./types";
 
 export const {
   deviceInfo,