rhombus-node-mcp 0.1.21 → 0.1.23

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

@@ -1,6 +1,123 @@
 import { logger } from "../logger.js";
 import { postApi } from "../network.js";
 export async function createVideoWall(options, requestModifiers, sessionId) {
+    // our grid layout settings is a little complicated. we'll dumb it down
+    // to certain presets based on length of device list
+    const numDevices = options?.settings.numVisibleDevicesAtOnce ??
+        options?.deviceList?.length ??
+        1;
+    let gridSettings;
+    if (numDevices <= 1) {
+        gridSettings = {
+            gridLayout: "1",
+            gridSize: {
+                width: 1,
+                height: 1,
+            },
+        };
+    }
+    else if (numDevices <= 2) {
+        gridSettings = {
+            gridLayout: "1\n2",
+            gridSize: {
+                width: 1,
+                height: 2,
+            },
+        };
+    }
+    else if (numDevices <= 3) {
+        gridSettings = {
+            gridLayout: "1 2\n1 3",
+            gridSize: {
+                width: 2,
+                height: 2,
+            },
+        };
+    }
+    else if (numDevices <= 4) {
+        gridSettings = {
+            gridLayout: "1 2\n3 4",
+            gridSize: {
+                width: 4,
+                height: 4,
+            },
+        };
+    }
+    else if (numDevices <= 5) {
+        gridSettings = {
+            gridLayout: "1 1 1 2\n   1 1 1 3\n   1 1 1 4\n   1 1 1 5",
+            gridSize: {
+                width: 4,
+                height: 4,
+            },
+        };
+    }
+    else if (numDevices <= 6) {
+        gridSettings = {
+            gridLayout: "1 2 3\n4 5 6",
+            gridSize: {
+                width: 3,
+                height: 2,
+            },
+        };
+    }
+    else if (numDevices <= 7) {
+        gridSettings = {
+            gridLayout: "1 1 2\n   1 1 3\n   4 5 6",
+            gridSize: {
+                width: 3,
+                height: 3,
+            },
+        };
+    }
+    else if (numDevices <= 9) {
+        gridSettings = {
+            gridLayout: "1 2 3\n4 5 6\n7 8 9",
+            gridSize: { width: 3, height: 3 },
+        };
+    }
+    else if (numDevices <= 12) {
+        gridSettings = {
+            gridLayout: "1 2 3 4\n5 6 7 8\n9 10 11 12",
+            gridSize: { width: 4, height: 3 },
+        };
+    }
+    else if (numDevices <= 16) {
+        gridSettings = {
+            gridLayout: "1 2 3 4\n5 6 7 8\n9 10 11 12\n13 14 15 16",
+            gridSize: { width: 4, height: 4 },
+        };
+    }
+    else if (numDevices <= 25) {
+        gridSettings = {
+            gridLayout: "1 2 3 4 5\n6 7 8 9 10\n11 12 13 14 15\n16 17 18 19 20\n21 22 23 24 25",
+            gridSize: { width: 5, height: 5 },
+        };
+    }
+    else if (numDevices <= 30) {
+        gridSettings = {
+            gridLayout: "1 2 3 4 5 6\n7 8 9 10 11 12\n13 14 15 16 17 18\n19 20 21 22 23 24\n25 26 27 28 29 30",
+            gridSize: { width: 6, height: 5 },
+        };
+    }
+    else if (numDevices <= 36) {
+        gridSettings = {
+            gridLayout: "1 2 3 4 5 6\n7 8 9 10 11 12\n13 14 15 16 17 18\n19 20 21 22 23 24\n25 26 27 28 29 30\n31 32 33 34 35 36",
+            gridSize: { width: 6, height: 6 },
+        };
+    }
+    else if (numDevices <= 49) {
+        gridSettings = {
+            gridLayout: "1 2 3 4 5 6 7\n8 9 10 11 12 13 14\n15 16 17 18 19 20 21\n22 23 24 25 26 27 28\n29 30 31 32 33 34 35\n36 37 38 39 40 41 42\n43 44 45 46 47 48 49",
+            gridSize: { width: 7, height: 7 },
+        };
+    }
+    else {
+        gridSettings = {
+            gridLayout: "1 2 3 4 5 6 7 8\n9 10 11 12 13 14 15 16\n17 18 19 20 21 22 23 24\n25 26 27 28 29 30 31 32\n33 34 35 36 37 38 39 40\n41 42 43 44 45 46 47 48\n49 50 51 52 53 54 55 56\n57 58 59 60 61 62 63 64",
+            gridSize: { width: 8, height: 8 },
+        };
+    }
     const body = {
         videoWall: {
             displayName: options?.displayName,
@@ -9,8 +126,7 @@ export async function createVideoWall(options, requestModifiers, sessionId) {
             orgUuid: options?.orgUuid,
             shared: true,
             settings: {
-                gridSize: { width: options?.settings.columnCount, height: options?.settings.columnCount },
-                gridLayout: "1 2\n3 4",
+                ...gridSettings,
                 intervalSeconds: options?.settings.intervalSeconds || 5,
             },
         },
@@ -23,31 +139,42 @@ export async function createVideoWall(options, requestModifiers, sessionId) {
     });
     return response;
 }
+export async function getVideoWalls(requestModifiers, sessionId) {
+    const response = await postApi({
+        route: "/camera/getVideoWalls",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (response?.error) {
+        return {
+            error: response.errorMsg ?? "No error message.",
+        };
+    }
+    return {
+        videoWalls: response?.videoWalls ?? [],
+    };
+}
 export async function handleCreateVideoWallRequest(videoWallCreateOptions, requestModifiers, sessionId) {
-    let text = "Unable to create video wall!";
     logger.info("🔨 Creating video wall");
     if (!videoWallCreateOptions?.displayName) {
-        text = JSON.stringify({
+        return {
             needUserInput: true,
             commandForUser: "What should the name of the video wall be?",
-        });
+        };
     }
     else if ((videoWallCreateOptions?.deviceList || []).length === 0) {
-        text = JSON.stringify({
+        return {
             needUserInput: true,
             commandForUser: "Which cameras would you like on this video wall?",
-        });
+        };
     }
     else {
         logger.info("Creating video wall with options: ", JSON.stringify(videoWallCreateOptions));
-        text = JSON.stringify(await createVideoWall(videoWallCreateOptions, requestModifiers, sessionId));
+        const response = await createVideoWall(videoWallCreateOptions, requestModifiers, sessionId);
+        return {
+            uuid: response?.uuid ?? undefined,
+            error: response?.errorMsg ?? undefined,
+        };
     }
-    return Promise.resolve({
-        content: [
-            {
-                type: "text",
-                text,
-            },
-        ],
-    });
 }

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

@@ -0,0 +1,66 @@
+import { postApi } from "../network.js";
+export async function getDoorControllerRules(doorControllerUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/doorcontroller/getDoorControllerRules",
+        body: { doorControllerUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.rules?.map((rule) => ({
+        uuid: rule.uuid ?? undefined,
+        name: rule.name ?? undefined,
+        deviceUuid: rule.deviceUuid ?? undefined,
+        enabled: rule.enabled ?? undefined,
+        ruleType: rule.ruleType ?? undefined,
+    })) ?? []);
+}
+export async function createDoorControllerRule(ruleConfig, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/doorcontroller/createDoorControllerRule",
+        body: ruleConfig,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return {
+        uuid: res.ruleUuid ?? undefined,
+        success: true,
+    };
+}
+export async function getDoorPolicies(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/policy/getDoorPolicies",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.policies?.map((policy) => ({
+        uuid: policy.uuid ?? undefined,
+        name: policy.name ?? undefined,
+        orgUuid: policy.orgUuid ?? undefined,
+        enabled: policy.enabled ?? undefined,
+    })) ?? []);
+}
+export async function createDoorPolicy(policyConfig, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/policy/createDoorPolicy",
+        body: policyConfig,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return {
+        uuid: res.policyUuid ?? undefined,
+        success: true,
+    };
+}

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

@@ -8,6 +8,73 @@ export const HumanEvent = z.object({
     timestamp: z.number(),
     id: z.number(),
 });
+const ACCESS_CONTROL_EVENT_BATCH_SIZE = 1000;
+const ACCESS_CONTROL_EVENT_TYPE_FILTER = ["CredentialReceivedEvent"];
+function mapAccessControlEvent(credEvent, timeZone) {
+    return {
+        authenticationResult: credEvent?.authenticationResult,
+        authorizationResult: credEvent?.authorizationResult,
+        doorUuid: credEvent?.componentCompositeUuid,
+        locationUuid: credEvent?.locationUuid,
+        user: credEvent?.originator?.username,
+        credSource: credEvent?.credSource,
+        timestampMs: credEvent?.timestampMs,
+        datetime: credEvent?.timestampMs ? formatTimestamp(credEvent.timestampMs, timeZone) : undefined,
+    };
+}
+async function getAccessControlEventsForDoor(doorUuid, startTime, endTime, timeZone, requestModifiers, sessionId) {
+    const allEvents = [];
+    let createdBeforeMs = endTime;
+    while (true) {
+        const body = {
+            accessControlledDoorUuid: doorUuid,
+            ...(startTime !== undefined ? { createdAfterMs: startTime } : {}),
+            ...(createdBeforeMs !== undefined ? { createdBeforeMs } : {}),
+            limit: ACCESS_CONTROL_EVENT_BATCH_SIZE,
+            typeFilter: ACCESS_CONTROL_EVENT_TYPE_FILTER,
+        };
+        const response = await postApi({
+            route: "/component/findComponentEventsByAccessControlledDoor",
+            body,
+            modifiers: requestModifiers,
+            sessionId,
+        });
+        const componentEvents = response.componentEvents || [];
+        if (componentEvents.length === 0) {
+            break;
+        }
+        const mappedEvents = componentEvents
+            .map((credEvent) => mapAccessControlEvent(credEvent, timeZone))
+            .filter(Boolean);
+        allEvents.push(...mappedEvents);
+        if (componentEvents.length < ACCESS_CONTROL_EVENT_BATCH_SIZE) {
+            break;
+        }
+        const oldestTimestamp = componentEvents.reduce((oldest, event) => {
+            const ts = event?.timestampMs;
+            if (typeof ts !== "number") {
+                return oldest;
+            }
+            if (oldest === null || ts < oldest) {
+                return ts;
+            }
+            return oldest;
+        }, null);
+        if (oldestTimestamp === null) {
+            break;
+        }
+        // createdBeforeMs is exclusive. Moving the window to the oldest seen timestamp
+        // prevents duplicate pages and keeps fetching older events until the range is exhausted.
+        if (createdBeforeMs !== undefined && oldestTimestamp >= createdBeforeMs) {
+            break;
+        }
+        if (startTime !== undefined && oldestTimestamp <= startTime) {
+            break;
+        }
+        createdBeforeMs = oldestTimestamp;
+    }
+    return allEvents;
+}
 export async function getFaceEvents(_locationUuid, timeZone, requestModifiers, sessionId) {
     const nowMs = Date.now();
     const rangeStartMs = nowMs - THREE_HOURS_MS;
@@ -47,36 +114,10 @@ export async function getFaceEvents(_locationUuid, timeZone, requestModifiers, s
     return response;
 }
 export async function getAccessControlEvents(doorUuids, startTime, endTime, timeZone, requestModifiers, sessionId) {
-    const bodies = doorUuids.map(doorUuid => ({
-        accessControlledDoorUuid: doorUuid,
-        ...(startTime ? { createdAfterMs: startTime } : {}),
-        ...(endTime ? { createdBeforeMs: endTime } : {}),
-        typeFilter: ["CredentialReceivedEvent"],
-    }));
-    const responses = await Promise.all(bodies.map(body => postApi({
-        route: "/component/findComponentEventsByAccessControlledDoor",
-        body,
-        modifiers: requestModifiers,
-        sessionId,
-    }).then(response => {
-        return (response.componentEvents || [])
-            .map((credEvent) => {
-            return {
-                authenticationResult: credEvent?.authenticationResult,
-                authorizationResult: credEvent?.authorizationResult,
-                doorUuid: credEvent?.componentCompositeUuid,
-                locationUuid: credEvent?.locationUuid,
-                user: credEvent?.originator?.username,
-                credSource: credEvent?.credSource,
-                datetime: credEvent?.timestampMs
-                    ? formatTimestamp(credEvent.timestampMs, timeZone)
-                    : undefined,
-            };
-        })
-            .filter(Boolean);
-    })));
+    const responses = await Promise.all(doorUuids.map(doorUuid => getAccessControlEventsForDoor(doorUuid, startTime, endTime, timeZone, requestModifiers, sessionId)));
     // Flatten all componentEvents into a single array
     const accessControlEvents = responses.flatMap(events => events);
+    accessControlEvents.sort((a, b) => (b.timestampMs || 0) - (a.timestampMs || 0));
     console.error(`componentEvents: ${JSON.stringify(accessControlEvents)}`);
     return accessControlEvents;
 }
@@ -318,3 +359,85 @@ startTime, endTime, timeZone, requestModifiers, sessionId) {
     console.error(`componentEvents: ${JSON.stringify(events)}`);
     return events;
 }
+export async function getButtonPressEvents(sensorUuid, startTime, endTime, timeZone, requestModifiers, sessionId) {
+    const body = {
+        sensorUuid,
+        ...(startTime ? { createdAfterMs: startTime } : {}),
+        ...(endTime ? { createdBeforeMs: endTime } : {}),
+    };
+    const response = await postApi({
+        route: "/button/getButtonPressEventsForSensor",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return (response.events || []).map(event => ({
+        timestampMs: event?.timestampMs ?? undefined,
+        datetime: event?.timestampMs ? formatTimestamp(event.timestampMs, timeZone) : undefined,
+        sensorUuid: event?.componentUuid ?? undefined,
+        buttonState: event?.buttonPress ?? undefined,
+    }));
+}
+export async function getOccupancyEvents(sensorUuid, startTime, endTime, timeZone, requestModifiers, sessionId) {
+    const body = {
+        sensorUuid,
+        ...(startTime ? { createdAfterMs: startTime } : {}),
+        ...(endTime ? { createdBeforeMs: endTime } : {}),
+    };
+    const response = await postApi({
+        route: "/occupancy/getOccupancyEventsForSensor",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return (response.occupancyEvents || response.events || []).map(event => ({
+        timestampMs: event.timestampMs ?? undefined,
+        datetime: event.timestampMs ? formatTimestamp(event.timestampMs, timeZone) : undefined,
+        sensorUuid: event.sensorUuid ?? event.componentUuid ?? undefined,
+        count: event.count ?? undefined,
+    }));
+}
+export async function getProximityEvents(tagUuids, startTime, endTime, timeZone, requestModifiers, sessionId) {
+    const allEvents = [];
+    for (const tagUuid of tagUuids) {
+        const body = {
+            tagUuid,
+            ...(startTime ? { createdAfterMs: startTime } : {}),
+            ...(endTime ? { createdBeforeMs: endTime } : {}),
+        };
+        const response = await postApi({
+            route: "/proximity/getProximityEventsForTag",
+            body,
+            modifiers: requestModifiers,
+            sessionId,
+        });
+        const mapped = (response.proximityEvents || []).map(event => ({
+            timestampMs: event.startTimeMs ?? undefined,
+            datetime: event.startTimeMs ? formatTimestamp(event.startTimeMs, timeZone) : undefined,
+            tagUuid: event.bleDeviceUuid ?? undefined,
+            rssi: event.bleRssi ?? undefined,
+        }));
+        allEvents.push(...mapped);
+    }
+    return allEvents;
+}
+export async function getDoorbellEvents(doorbellCameraUuid, startTime, endTime, timeZone, requestModifiers, sessionId) {
+    const body = {
+        doorbellCameraUuid,
+        limit: 100,
+        ...(startTime ? { createdAfterMs: startTime } : {}),
+        ...(endTime ? { createdBeforeMs: endTime } : {}),
+    };
+    const response = await postApi({
+        route: "/doorbellcamera/findComponentEventsForDoorbellCamera",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return (response.componentEvents || []).map(event => ({
+        timestampMs: event.timestampMs ?? undefined,
+        datetime: event.timestampMs ? formatTimestamp(event.timestampMs, timeZone) : undefined,
+        doorbellCameraUuid: event.componentUuid ?? undefined,
+        eventType: event.type ?? undefined,
+    }));
+}

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

@@ -2,103 +2,58 @@ 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;
-            }
+    // OptionalNullable so that we can remove some fields before sending to the API
+    let filteredArgs = { ...args };
+    if (filteredArgs.pageRequest && filteredArgs.pageRequest.lastEvaluatedKey === "") {
+        delete filteredArgs.pageRequest.lastEvaluatedKey;
+    }
+    if (filteredArgs.searchFilter) {
+        if (filteredArgs.searchFilter.faceNames &&
+            filteredArgs.searchFilter.faceNames.length === 0) {
+            // @ts-expect-error - we can break typing
+            delete filteredArgs.searchFilter.faceNames;
         }
-        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;
-                }
-            }
+        if (filteredArgs.searchFilter.labels &&
+            filteredArgs.searchFilter.labels.length === 0) {
+            // @ts-expect-error - we can break typing
+            delete filteredArgs.searchFilter.labels;
+        }
+        if (filteredArgs.searchFilter.hasEmbedding === false) {
+            delete filteredArgs.searchFilter.hasEmbedding;
         }
-        // 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,
-                    },
-                };
+        if (filteredArgs.searchFilter.hasName === false) {
+            delete filteredArgs.searchFilter.hasName;
+        }
+        if (filteredArgs.searchFilter.timestampFilter) {
+            if (filteredArgs.searchFilter.timestampFilter.rangeEnd === null) {
+                delete filteredArgs.searchFilter.timestampFilter.rangeEnd;
             }
-            else {
-                hasMore = false;
+            if (filteredArgs.searchFilter.timestampFilter.rangeStart === null) {
+                delete filteredArgs.searchFilter.timestampFilter.rangeStart;
             }
         }
-        else {
-            hasMore = false;
-        }
     }
-    return allFaceEvents;
+    filteredArgs = removeNulls(filteredArgs);
+    const response = await postApi({
+        route: "/faceRecognition/faceEvent/findFaceEventsByOrg",
+        body: filteredArgs,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    const faceEvents = (response?.faceEvents ?? []).map((event) => ({
+        deviceUuid: event.deviceUuid,
+        eventTimestampMs: event.eventTimestamp,
+        eventTimestamp: formatTimestamp(event.eventTimestamp, timeZone),
+        faceName: event.faceName,
+        locationUuid: event.locationUuid,
+        personUuid: event.personUuid,
+        thumbnailS3Key: event.thumbnailS3Key,
+        uuid: event.uuid,
+    }));
+    return {
+        faceEvents,
+        lastEvaluatedKey: response?.lastEvaluatedKey,
+    };
 }
 export async function getRegisteredFaces(_args, requestModifiers, sessionId) {
     return await postApi({
@@ -108,3 +63,75 @@ export async function getRegisteredFaces(_args, requestModifiers, sessionId) {
         sessionId,
     });
 }
+export async function getPersonLabels(requestModifiers, sessionId) {
+    return await postApi({
+        route: "/faceRecognition/person/findPersonLabelsByOrg",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+}
+export async function searchSimilarFaces(faceEventUuid, timeZone, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/faceRecognition/faceEvent/findSimilarFaceEvents",
+        body: { faceEventUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return (res.faceEvents || []).map((event) => ({
+        uuid: event.uuid ?? undefined,
+        personUuid: event.personUuid ?? undefined,
+        similarity: event.similarity ?? undefined,
+        eventTimestamp: event.eventTimestamp
+            ? formatTimestamp(event.eventTimestamp, timeZone)
+            : undefined,
+    }));
+}
+export async function getFaceMatchmakers(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/faceRecognition/matchmaker/findFaceMatchmakersByOrg",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return (res.faceMatchmakers || []).map((m) => ({
+        uuid: m.uuid ?? undefined,
+        personUuid: m.personUuid ?? undefined,
+        name: m.name ?? undefined,
+    }));
+}
+export async function getFaceEventsByPerson(personUuid, timeZone, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/faceRecognition/faceEvent/findFaceEventsByOrg",
+        body: {
+            pageRequest: { maxPageSize: 75 },
+            searchFilter: {
+                personUuids: [personUuid],
+                deviceUuids: [],
+                faceNames: [],
+                labels: [],
+                locationUuids: [],
+            },
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    const faceEvents = (res.faceEvents || []).map((event) => ({
+        uuid: event.uuid ?? undefined,
+        personUuid: event.personUuid ?? undefined,
+        eventTimestamp: event.eventTimestamp
+            ? formatTimestamp(event.eventTimestamp, timeZone)
+            : undefined,
+        deviceUuid: event.deviceUuid ?? undefined,
+    }));
+    return {
+        faceEvents,
+        lastEvaluatedKey: res.lastEvaluatedKey,
+    };
+}

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

@@ -47,6 +47,8 @@ export async function getAccessControlledDoors(requestModifiers, sessionId) {
                     geofenceEnabled: door.geofenceEnabled,
                     locationUuid: door.locationUuid,
                     policyUuid: door.policyUuid,
+                    remoteUnlockEnabled: door.remoteUnlockEnabled,
+                    associatedCameras: door.associatedCameras?.filter((c) => c !== null) ?? [],
                     name: door.name,
                     uuid: door.uuid,
                 };