rhombus-node-mcp 0.1.13 → 0.1.16

package/dist/api/faces-tool-api.js

@@ -0,0 +1,110 @@
+import { postApi } from "../network.js";
+import { formatTimestamp } from "../util.js";
+import { removeNulls } from "../utils/remove-nulls.js";
+export async function getFaceEvents(args, timeZone, requestModifiers, sessionId) {
+    let allFaceEvents = [];
+    let currentArgs = { ...args };
+    let hasMore = true;
+    let lastResponse = null;
+    while (hasMore) {
+        // Filter out empty/undefined fields from currentArgs
+        // OptionalNullable so that we can remove some fields before returning them to the MCP client
+        let filteredArgs = { ...currentArgs };
+        if (filteredArgs.pageRequest) {
+            if (filteredArgs.pageRequest.lastEvaluatedKey === "") {
+                delete filteredArgs.pageRequest.lastEvaluatedKey;
+            }
+        }
+        if (filteredArgs.searchFilter) {
+            // Remove empty arrays
+            // if (
+            //   filteredArgs.searchFilter.deviceUuids &&
+            //   filteredArgs.searchFilter.deviceUuids.length === 0
+            // ) {
+            //   // @ts-expect-error - we can break typing
+            //   delete filteredArgs.searchFilter.deviceUuids;
+            // }
+            if (filteredArgs.searchFilter.faceNames && filteredArgs.searchFilter.faceNames.length === 0) {
+                // @ts-expect-error - we can break typing
+                delete filteredArgs.searchFilter.faceNames;
+            }
+            if (filteredArgs.searchFilter.labels && filteredArgs.searchFilter.labels.length === 0) {
+                // @ts-expect-error - we can break typing
+                delete filteredArgs.searchFilter.labels;
+            }
+            // Remove empty strings
+            // if (filteredArgs.searchFilter.faceNameContains === "") {
+            //   delete filteredArgs.searchFilter.faceNameContains;
+            // }
+            // Remove false booleans
+            if (filteredArgs.searchFilter.hasEmbedding === false) {
+                delete filteredArgs.searchFilter.hasEmbedding;
+            }
+            if (filteredArgs.searchFilter.hasName === false) {
+                delete filteredArgs.searchFilter.hasName;
+            }
+            // if there is no timestampFilter, we can remove it
+            // rangeEnd and rangeStart are ISO 8601 strings
+            if (filteredArgs.searchFilter.timestampFilter) {
+                if (filteredArgs.searchFilter.timestampFilter.rangeEnd === null) {
+                    delete filteredArgs.searchFilter.timestampFilter.rangeEnd;
+                }
+                if (filteredArgs.searchFilter.timestampFilter.rangeStart === null) {
+                    delete filteredArgs.searchFilter.timestampFilter.rangeStart;
+                }
+            }
+        }
+        // one last sweep of null values
+        console.log("filteredArgs", filteredArgs);
+        filteredArgs = removeNulls(filteredArgs);
+        const response = await postApi({
+            route: "/faceRecognition/faceEvent/findFaceEventsByOrg",
+            body: filteredArgs,
+            modifiers: requestModifiers,
+            sessionId,
+        });
+        lastResponse = response;
+        // Filter the faceEvents to only include the specified fields
+        if (response && response.faceEvents) {
+            const filteredEvents = response.faceEvents.map((event) => ({
+                deviceUuid: event.deviceUuid,
+                eventTimestampMs: event.eventTimestamp,
+                eventTimestamp: formatTimestamp(event.eventTimestamp, timeZone),
+                faceName: event.faceName,
+                locationUuid: event.locationUuid,
+                personUuid: event.personUuid,
+                // selectedPersonMatch: event.selectedPersonMatch,
+                thumbnailS3Key: event.thumbnailS3Key,
+                // topPersonMatches: event.topPersonMatches,
+                uuid: event.uuid,
+            }));
+            allFaceEvents.push(...filteredEvents);
+            // Check if we should continue pagination
+            if (response.faceEvents.length === 100 && response.lastEvaluatedKey) {
+                // Update the pageRequest for the next iteration
+                currentArgs = {
+                    ...currentArgs,
+                    pageRequest: {
+                        maxPageSize: currentArgs.pageRequest?.maxPageSize || 100,
+                        lastEvaluatedKey: response.lastEvaluatedKey,
+                    },
+                };
+            }
+            else {
+                hasMore = false;
+            }
+        }
+        else {
+            hasMore = false;
+        }
+    }
+    return allFaceEvents;
+}
+export async function getRegisteredFaces(_args, requestModifiers, sessionId) {
+    return await postApi({
+        route: "/faceRecognition/person/findPeopleByOrg",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+}

package/dist/api/get-entity-tool-api.js

@@ -0,0 +1,176 @@
+import { logger } from "../logger.js";
+import { postApi } from "../network.js";
+import { formatTimestamp } from "../util.js";
+import { tempFunc } from "../utils/temp.js";
+export async function getCameraList(requestModifiers, sessionId) {
+    return {
+        cameras: (await postApi({
+            route: "/camera/getMinimalCameraStateList",
+            body: {},
+            modifiers: requestModifiers,
+            sessionId,
+        })).cameraStates.filter((camera) => !!camera.locationUuid),
+    };
+}
+export async function getDoorbellCameras(requestModifiers, sessionId) {
+    return {
+        doorbellCameras: (await postApi({
+            route: "/doorbellcamera/getMinimalStateList",
+            body: {},
+            modifiers: requestModifiers,
+            sessionId,
+        })).minimalStates.filter((doorbellCamera) => !!doorbellCamera.locationUuid),
+    };
+}
+export async function getBadgeReaders(requestModifiers, sessionId) {
+    return await postApi({
+        route: "/badgereader/getMinimalStateList",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    }).then(response => {
+        return {
+            badgeReaders: response.minimalStates.filter((badgeReader) => !!badgeReader.locationUuid),
+        };
+    });
+}
+export async function getAccessControlledDoors(requestModifiers, sessionId) {
+    return await postApi({
+        route: "/component/findAccessControlledDoors",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    }).then(response => {
+        return {
+            accessControlledDoors: (response.accessControlledDoors || []).map((door) => {
+                return {
+                    geofenceEnabled: door.geofenceEnabled,
+                    locationUuid: door.locationUuid,
+                    policyUuid: door.policyUuid,
+                    name: door.name,
+                    uuid: door.uuid,
+                };
+            }),
+        };
+    });
+}
+export async function getAudioGateways(timeZone, requestModifiers, sessionId) {
+    return await postApi({
+        route: "/audiogateway/getMinimalAudioGatewayStateList",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    }).then(response => {
+        return {
+            audioGateways: response.audioGatewayStates
+                .filter((camera) => !!camera.locationUuid)
+                .map((gateway) => ({
+                ...gateway,
+                createdAtString: gateway.createdAtMillis
+                    ? formatTimestamp(gateway.createdAtMillis, timeZone)
+                    : undefined,
+            })),
+        };
+    });
+}
+export async function getDoorSensors(requestModifiers, sessionId) {
+    return await postApi({
+        route: "/door/getMinimalDoorStateList",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    }).then(response => {
+        return {
+            doorStates: response.doorStates.filter((door) => !!door.locationUuid),
+        };
+    });
+}
+export async function getEnvironmentalSensors(timeZone, tempUnit, requestModifiers, sessionId) {
+    return await postApi({
+        route: "/climate/getMinimalClimateStateList",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    }).then(response => {
+        logger.info("Using tempUnit: ", tempUnit);
+        return {
+            climateStates: response.climateStates
+                .filter((sensor) => !!sensor.locationUuid)
+                .map((_sensor) => {
+                const { temperatureCelcius, ...sensor } = _sensor;
+                return {
+                    ...sensor,
+                    temperature: tempFunc(temperatureCelcius ?? 0, tempUnit),
+                    createdAtString: sensor.createdAtMillis
+                        ? formatTimestamp(sensor.createdAtMillis, timeZone)
+                        : undefined,
+                };
+            }),
+        };
+    });
+}
+export async function getMotionSensors(requestModifiers, sessionId) {
+    return await postApi({
+        route: "/occupancy/getMinimalOccupancySensorStateList",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    }).then(response => {
+        return {
+            occupancySensorStates: response.occupancySensorStates.filter((occupancySensor) => !!occupancySensor.locationUuid),
+        };
+    });
+}
+export async function getButtons(timeZone, requestModifiers, sessionId) {
+    return await postApi({
+        route: "/button/getMinimalButtonStateList",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    }).then(response => {
+        return {
+            buttonStates: response.states
+                .filter((button) => !!button.locationUuid)
+                .map((button) => ({
+                ...button,
+                createdAtString: button.createdAtMillis
+                    ? formatTimestamp(button.createdAtMillis, timeZone)
+                    : undefined,
+            })),
+        };
+    });
+}
+export async function getKeypads(requestModifiers, sessionId) {
+    return await postApi({
+        route: "/keypad/getKeypadsForOrg",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    }).then(response => {
+        return {
+            keypadStates: response.keypads.filter((keypad) => !!keypad.locationUuid),
+        };
+    });
+}
+export async function getEnvironmentalGateways(timeZone, requestModifiers, sessionId) {
+    return await postApi({
+        route: "/climate/getMinimalEnvironmentalGatewayStates",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    }).then(response => {
+        return {
+            minimalEnvironmentalGatewayStates: response.minimalEnvironmentalGatewayStates
+                .filter((gateway) => !!gateway.locationUuid)
+                .map((gateway) => ({
+                ...gateway,
+                createdAtString: gateway.createdAtMillis
+                    ? formatTimestamp(gateway.createdAtMillis, timeZone)
+                    : undefined,
+                timestampString: gateway.timestampMs
+                    ? formatTimestamp(gateway.timestampMs, timeZone)
+                    : undefined,
+            })),
+        };
+    });
+}

package/dist/api/get-org-information-tool-api.js

@@ -0,0 +1,9 @@
+import { postApi } from "../network.js";
+export async function getOrg(requestModifiers, sessionId) {
+    return await postApi({
+        route: "/org/getOrgV2",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+}

package/dist/api/location-tool-api.js

@@ -0,0 +1,9 @@
+import { postApi } from "../network.js";
+export async function getLocations(requestModifiers, sessionId) {
+    return await postApi({
+        route: "/location/getLocationsV2",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+}

package/dist/api/lpr-tool-api.js

@@ -0,0 +1,68 @@
+import { postApi } from "../network.js";
+import { formatTimestamp } from "../util.js";
+export async function getVehicleEvents(args, timeZone, requestModifiers, sessionId) {
+    const requestArgs = {
+        deviceUuidFilter: args.deviceUuidFilter,
+        locationUuidFilter: args.locationUuidFilter,
+        vehicleLabelQuery: args.vehicleLabelQuery,
+        licensePlateFuzzyQuery: args.licensePlateFuzzyQuery,
+        startTimeMs: args.startTime ? new Date(args.startTime).getTime() : undefined,
+        endTimeMs: args.endTime ? new Date(args.endTime).getTime() : undefined,
+    };
+    const res = await postApi({
+        route: "/vehicle/getVehicleEvents",
+        body: requestArgs,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.events?.map(event => ({
+        uuid: event.uuid ?? "",
+        deviceUuid: event.deviceUuid ?? undefined,
+        eventTimestamp: formatTimestamp(event.eventTimestamp ?? Date.now(), timeZone),
+        imageS3Key: event.imageS3Key ?? undefined,
+        thumbnailS3Key: event.thumbnailS3Key ?? undefined,
+        locationUuid: event.locationUuid ?? undefined,
+        vehicleLicensePlate: event.vehicleLicensePlate ?? "No License Plate",
+    })) ?? []);
+}
+export async function getSavedVehicles(timeZone, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/vehicle/getVehicles",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.vehicles?.map(vehicle => ({
+        createdTimestamp: formatTimestamp(vehicle.createdAtMillis ?? Date.now(), timeZone),
+        name: vehicle.name ?? "No Name",
+        description: vehicle.description ?? "No Description",
+        licensePlate: vehicle.licensePlate ?? "No License Plate",
+        orgUuid: vehicle.orgUuid ?? "",
+    })) ?? []);
+}
+export async function getVehicleLabels(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/vehicle/getVehicleLabelsForOrg",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    const processedVehicleLabels = {};
+    for (const [licensePlate, labels] of Object.entries(res.vehicleLabels ?? {})) {
+        const filteredLabels = labels?.filter(label => label !== null) ?? [];
+        if (!filteredLabels || filteredLabels.length === 0) {
+            continue;
+        }
+        processedVehicleLabels[licensePlate] = filteredLabels;
+    }
+    return processedVehicleLabels;
+}

package/dist/api/policy-alerts-tool-api.js

@@ -0,0 +1,42 @@
+import { postApi } from "../network.js";
+import { formatTimestamp } from "../util.js";
+export async function getPolicyAlerts(args, requestModifiers, sessionId) {
+    return await postApi({
+        route: "/event/getPolicyAlerts",
+        body: args,
+        modifiers: requestModifiers,
+        sessionId,
+    }).then(response => {
+        return {
+            ...response,
+            policyAlerts: (response.policyAlerts || []).map((alert) => ({
+                ...alert,
+                labels: [
+                    ...(alert.alertingEventFaces || []),
+                    ...(alert.alertingEventVehicles || []),
+                ].flatMap(alert => alert.labels),
+                createdOnString: alert.timestampMs
+                    ? formatTimestamp(alert.timestampMs, args.timeZone)
+                    : undefined,
+            })),
+        };
+    });
+}
+export async function getExpiringPolicyAlerts(args, requestModifiers, sessionId) {
+    return await postApi({
+        route: "/event/getExpiringPolicyAlerts",
+        body: args,
+        modifiers: requestModifiers,
+        sessionId,
+    }).then(response => {
+        return {
+            ...response,
+            policyAlerts: (response.policyAlerts || []).map((alert) => ({
+                ...alert,
+                createdOnString: alert.timestampMs
+                    ? formatTimestamp(alert.timestampMs)
+                    : undefined,
+            })),
+        };
+    });
+}

package/dist/api/reboot-cameras-tool-api.js

@@ -0,0 +1,34 @@
+import { postApi } from "../network.js";
+export async function rebootCameras(cameraUuids, requestModifiers, sessionId) {
+    let successCount = 0;
+    let errorCount = 0;
+    for (const cameraUuid of cameraUuids) {
+        try {
+            const body = { cameraUuid };
+            const response = await postApi({
+                route: "/camera/reboot",
+                body,
+                modifiers: requestModifiers,
+                sessionId,
+            });
+            if (response.error) {
+                errorCount++;
+            }
+            else {
+                successCount++;
+            }
+        }
+        catch (error) {
+            const ret = `Error rebooting cameras: ${error}`;
+            return { error: true, status: ret };
+        }
+    }
+    let status;
+    if (successCount === cameraUuids.length)
+        status = "SUCCESS";
+    else if (successCount > 0 && successCount < cameraUuids.length)
+        status = "PARTIAL_SUCCESS";
+    else
+        status = "ERROR";
+    return { status, successCount, errorCount };
+}