rhombus-node-mcp 0.1.26 → 0.1.28

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

@@ -45,14 +45,15 @@ function buildDateRangeFilter(filter) {
         localEndDateRangeEnd,
     };
 }
-async function verifyExceptionConfig(exception, requestModifiers, sessionId) {
+async function verifyExceptionConfig(exception, options, requestModifiers, sessionId) {
     const verified = {
         ...exception,
     };
-    const cleanedDoorUuids = (Array.isArray(exception.doorUuids)
-        ? exception.doorUuids.filter((doorUuid) => !!doorUuid)
-        : []) ?? [];
-    if (cleanedDoorUuids.length > 0) {
+    const doorUuidsProvided = Array.isArray(exception.doorUuids);
+    const cleanedDoorUuids = doorUuidsProvided
+        ? (exception.doorUuids?.filter((doorUuid) => !!doorUuid) ?? [])
+        : undefined;
+    if (cleanedDoorUuids !== undefined) {
         verified.doorUuids = cleanedDoorUuids;
     }
     if ((!Array.isArray(exception.intervals) || exception.intervals.length === 0) &&
@@ -67,27 +68,33 @@ async function verifyExceptionConfig(exception, requestModifiers, sessionId) {
             },
         ];
     }
-    // construct locationToDoorsMap
-    const locationToDoorsMap = {};
-    if (cleanedDoorUuids.length > 0) {
-        const doors = await getAccessControlledDoors(requestModifiers, sessionId);
-        const doorsMap = await createUuidMap(doors.accessControlledDoors ?? [], "uuid");
-        for (const doorUuid of cleanedDoorUuids) {
-            const door = doorsMap.get(doorUuid);
-            const locationUuid = door?.locationUuid;
-            if (locationUuid) {
-                if (!locationToDoorsMap[locationUuid]) {
-                    locationToDoorsMap[locationUuid] = [];
+    // construct locationToDoorsMap only when doors are explicitly provided.
+    // For update, omitting doorUuids should preserve the existing map.
+    if (cleanedDoorUuids !== undefined) {
+        const locationToDoorsMap = {};
+        if (cleanedDoorUuids.length > 0) {
+            const doors = await getAccessControlledDoors(requestModifiers, sessionId);
+            const doorsMap = await createUuidMap(doors.accessControlledDoors ?? [], "uuid");
+            for (const doorUuid of cleanedDoorUuids) {
+                const door = doorsMap.get(doorUuid);
+                const locationUuid = door?.locationUuid;
+                if (locationUuid) {
+                    if (!locationToDoorsMap[locationUuid]) {
+                        locationToDoorsMap[locationUuid] = [];
+                    }
+                    locationToDoorsMap[locationUuid].push(doorUuid);
                 }
-                locationToDoorsMap[locationUuid].push(doorUuid);
             }
         }
+        verified.locationToDoorsMap = locationToDoorsMap;
+    }
+    else if (!options.isUpdate) {
+        verified.locationToDoorsMap = {};
     }
-    verified.locationToDoorsMap = locationToDoorsMap;
     return verified;
 }
 export async function createDoorScheduleException(exception, requestModifiers, sessionId) {
-    const normalizedException = await verifyExceptionConfig(exception, requestModifiers, sessionId);
+    const normalizedException = await verifyExceptionConfig(exception, { isUpdate: false }, requestModifiers, sessionId);
     const res = await postApi({
         route: "/accesscontrol/doorScheduleException/createExceptionV2",
         body: {
@@ -103,7 +110,7 @@ export async function createDoorScheduleException(exception, requestModifiers, s
     };
 }
 export async function updateDoorScheduleException(exception, requestModifiers, sessionId) {
-    const normalizedException = await verifyExceptionConfig(exception, requestModifiers, sessionId);
+    const normalizedException = await verifyExceptionConfig(exception, { isUpdate: true }, requestModifiers, sessionId);
     const res = await postApi({
         route: "/accesscontrol/doorScheduleException/updateExceptionV2",
         body: {

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

@@ -3,23 +3,25 @@ import { postApi } from "../network/network.js";
 import { formatTimestamp } from "../util.js";
 import { tempFunc } from "../utils/temp.js";
 export async function getCameraList(requestModifiers, sessionId) {
+    const body = await postApi({
+        route: "/camera/getMinimalCameraStateList",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
     return {
-        cameras: (await postApi({
-            route: "/camera/getMinimalCameraStateList",
-            body: {},
-            modifiers: requestModifiers,
-            sessionId,
-        })).cameraStates.filter((camera) => !!camera.locationUuid),
+        cameras: (body.cameraStates ?? []).filter((camera) => !!camera.locationUuid),
     };
 }
 export async function getDoorbellCameras(requestModifiers, sessionId) {
+    const body = await postApi({
+        route: "/doorbellcamera/getMinimalStateList",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
     return {
-        doorbellCameras: (await postApi({
-            route: "/doorbellcamera/getMinimalStateList",
-            body: {},
-            modifiers: requestModifiers,
-            sessionId,
-        })).minimalStates.filter((doorbellCamera) => !!doorbellCamera.locationUuid),
+        doorbellCameras: (body.minimalStates ?? []).filter((doorbellCamera) => !!doorbellCamera.locationUuid),
     };
 }
 export async function getBadgeReaders(requestModifiers, sessionId) {
@@ -30,7 +32,7 @@ export async function getBadgeReaders(requestModifiers, sessionId) {
         sessionId,
     }).then((response) => {
         return {
-            badgeReaders: response.minimalStates.filter((badgeReader) => !!badgeReader.locationUuid),
+            badgeReaders: (response.minimalStates ?? []).filter((badgeReader) => !!badgeReader.locationUuid),
         };
     });
 }
@@ -65,7 +67,7 @@ export async function getAudioGateways(timeZone, requestModifiers, sessionId) {
         sessionId,
     }).then((response) => {
         return {
-            audioGateways: response.audioGatewayStates
+            audioGateways: (response.audioGatewayStates ?? [])
                 .filter((camera) => !!camera.locationUuid)
                 .map((gateway) => ({
                 ...gateway,
@@ -84,7 +86,7 @@ export async function getDoorSensors(requestModifiers, sessionId) {
         sessionId,
     }).then((response) => {
         return {
-            doorStates: response.doorStates.filter((door) => !!door.locationUuid),
+            doorStates: (response.doorStates ?? []).filter((door) => !!door.locationUuid),
         };
     });
 }
@@ -97,7 +99,7 @@ export async function getEnvironmentalSensors(timeZone, tempUnit, requestModifie
     }).then((response) => {
         logger.info("Using tempUnit: ", tempUnit);
         return {
-            climateStates: response.climateStates
+            climateStates: (response.climateStates ?? [])
                 .filter((sensor) => !!sensor.locationUuid)
                 .map((_sensor) => {
                 const { temperatureCelcius, ...sensor } = _sensor;
@@ -120,7 +122,7 @@ export async function getMotionSensors(requestModifiers, sessionId) {
         sessionId,
     }).then((response) => {
         return {
-            occupancySensorStates: response.occupancySensorStates.filter((occupancySensor) => !!occupancySensor.locationUuid),
+            occupancySensorStates: (response.occupancySensorStates ?? []).filter((occupancySensor) => !!occupancySensor.locationUuid),
         };
     });
 }
@@ -132,7 +134,7 @@ export async function getButtons(timeZone, requestModifiers, sessionId) {
         sessionId,
     }).then((response) => {
         return {
-            buttonStates: response.states
+            buttonStates: (response.states ?? [])
                 .filter((button) => !!button.locationUuid)
                 .map((button) => ({
                 ...button,
@@ -151,7 +153,7 @@ export async function getKeypads(requestModifiers, sessionId) {
         sessionId,
     }).then((response) => {
         return {
-            keypadStates: response.keypads.filter((keypad) => !!keypad.locationUuid),
+            keypadStates: (response.keypads ?? []).filter((keypad) => !!keypad.locationUuid),
         };
     });
 }
@@ -163,7 +165,7 @@ export async function getEnvironmentalGateways(timeZone, requestModifiers, sessi
         sessionId,
     }).then((response) => {
         return {
-            minimalEnvironmentalGatewayStates: response.minimalEnvironmentalGatewayStates
+            minimalEnvironmentalGatewayStates: (response.minimalEnvironmentalGatewayStates ?? [])
                 .filter((gateway) => !!gateway.locationUuid)
                 .map((gateway) => ({
                 ...gateway,

package/dist/logger.js

@@ -17,7 +17,7 @@ catch (error) {
 const appenders = {
     // stderr for terminal visibility (always available)
     stderr: { type: "stderr" },
-    // only send warn+ to stderr (never stdout)
+    // production stderr: hide trace/debug (e.g. full response snippets); still shows info+ like [POSTAPI] REQUEST
     stderrInfo: {
         type: "logLevelFilter",
         appender: "stderr",
@@ -36,7 +36,8 @@ if (fileLoggingEnabled) {
         layout: { type: "basic" },
     };
 }
-const stderrAppender = process.env.DEBUG === "true" ? "stderr" : "stderrInfo";
+const isProduction = process.env.NODE_ENV === "production";
+const stderrAppender = isProduction ? "stderrInfo" : "stderr";
 // Configure categories based on available appenders
 const categories = {
     default: {

package/dist/tools/door-schedule-exception-tool.js

@@ -1,5 +1,5 @@
 import { createDoorScheduleException, deleteDoorScheduleException, findDoorScheduleExceptions, findDoorScheduleExceptionsForDoor, findDoorScheduleExceptionsForLocation, getDoorScheduleException, updateDoorScheduleException, } from "../api/door-schedule-exception-tool-api.js";
-import { DoorScheduleExceptionRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/door-schedule-exception-tool-types.js";
+import { CREATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA, DoorScheduleExceptionRequestType, OUTPUT_SCHEMA, TOOL_ARGS, UPDATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA, } from "../types/door-schedule-exception-tool-types.js";
 import { createToolStructuredContent, createToolTextContent, extractFromToolExtra, } from "../util.js";
 const TOOL_NAME = "door-schedule-exception-tool";
 const TOOL_DESCRIPTION = `
@@ -9,6 +9,10 @@ If a lock/unlock exception is enabled, it will overwrite the existing lock/unloc
 A schedule exception allows you to create a custom schedule that is only active for the specified dates/times. 
 Once the date/time a schedule exception is set for passes, the original schedule will resume.
 
+Door schedule exceptions can be either expired or not expired. If its scheduled date is in the past, then it is expired.
+Users through the web console can toggle whether to see expired door schedule exceptions or not. Please mirror this behavior
+when responding to the user.
+
 It has the following modes of operation, determined by the "requestType" parameter:
 - ${DoorScheduleExceptionRequestType.CREATE_EXCEPTION}: Create a door schedule exception. Requires exception (DoorScheduleExceptionType object). If locationUuid is missing but doorUuids are provided, the tool will resolve the location automatically.
 - ${DoorScheduleExceptionRequestType.DELETE_EXCEPTION}: Delete a door schedule exception. Requires exceptionUuid.
@@ -38,7 +42,13 @@ const TOOL_HANDLER = async (args, _extra) => {
                         error: "exception is required for create-exception.",
                     }));
                 }
-                const created = await createDoorScheduleException(args.exception, requestModifiers, sessionId);
+                const parsedException = CREATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA.safeParse(args.exception);
+                if (!parsedException.success) {
+                    return createToolTextContent(JSON.stringify({
+                        error: parsedException.error.issues[0]?.message ?? "Invalid exception payload for create-exception.",
+                    }));
+                }
+                const created = await createDoorScheduleException(parsedException.data, requestModifiers, sessionId);
                 return createToolStructuredContent(created);
             }
             case DoorScheduleExceptionRequestType.DELETE_EXCEPTION: {
@@ -87,7 +97,14 @@ const TOOL_HANDLER = async (args, _extra) => {
                         error: "exception is required for update-exception.",
                     }));
                 }
-                const updated = await updateDoorScheduleException(args.exception, requestModifiers, sessionId);
+                const parsedException = UPDATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA.safeParse(args.exception);
+                if (!parsedException.success) {
+                    return createToolTextContent(JSON.stringify({
+                        error: parsedException.error.issues[0]?.message ??
+                            "Invalid exception payload for update-exception.",
+                    }));
+                }
+                const updated = await updateDoorScheduleException(parsedException.data, requestModifiers, sessionId);
                 return createToolStructuredContent(updated);
             }
         }

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

@@ -14,7 +14,9 @@ includes a "connected" boolean field indicating whether it is currently online (
 When asked about device health, offline devices, or connectivity issues, use this tool to fetch all device
 types and check the "connected" field to identify which devices are offline or unreachable.`;
 const TOOL_HANDLER = async (args, extra) => {
-    const { entityTypes, timeZone, filterBy, tempUnit } = args;
+    const { entityTypes, timeZone, tempUnit } = args;
+    const filterBy = args.filterBy ?? { locationUuids: null };
+    const locationFilter = filterBy.locationUuids;
     const { requestModifiers, sessionId } = extractFromToolExtra(extra);
     const promises = [];
     if (entityTypes.includes(DeviceType.CAMERA)) {
@@ -61,8 +63,10 @@ const TOOL_HANDLER = async (args, extra) => {
                 // then filter
                 response[key] = value.filter((item) => {
                     let pass = true;
-                    if (item.locationUuid && filterBy.locationUuids && filterBy.locationUuids.length > 0) {
-                        pass = pass && filterBy.locationUuids.includes(item.locationUuid);
+                    if (item.locationUuid &&
+                        locationFilter &&
+                        locationFilter.length > 0) {
+                        pass = pass && locationFilter.includes(item.locationUuid);
                     }
                     return pass;
                 });

package/dist/types/door-schedule-exception-tool-types.js

@@ -11,29 +11,29 @@ export var DoorScheduleExceptionRequestType;
     DoorScheduleExceptionRequestType["GET_EXCEPTION"] = "get-exception";
     DoorScheduleExceptionRequestType["UPDATE_EXCEPTION"] = "update-exception";
 })(DoorScheduleExceptionRequestType || (DoorScheduleExceptionRequestType = {}));
-export const DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA = z
+const DOOR_INTERVAL_SCHEMA = z.object({
+    localEndDateTime: z.string().nullable(),
+    localStartDateTime: z.string().nullable(),
+    state: z.enum(AccessControlledDoorStateEnumType),
+});
+const DOOR_SCHEDULE_EXCEPTION_BASE_SCHEMA = z
     .object({
-    createdAtMillis: z.number().nullable(),
-    defaultState: z.enum(AccessControlledDoorStateEnumType).nullable(),
-    description: z.string().nullable(),
+    uuid: z.string().nullable().optional(),
+    createdAtMillis: z.number().nullable().optional(),
+    defaultState: z.enum(AccessControlledDoorStateEnumType).nullable().optional(),
+    description: z.string().nullable().optional(),
     doorUuids: z.array(z.string().nullable()).nullable().optional(),
-    intervals: z
-        .array(z.object({
-        localEndDateTime: z.string().nullable(),
-        localStartDateTime: z.string().nullable(),
-        state: z.enum(AccessControlledDoorStateEnumType),
-    }))
-        .nullable(),
-    localEndDate: z.string().nullable(),
-    localStartDate: z.string().nullable(),
+    intervals: z.array(DOOR_INTERVAL_SCHEMA).nullable().optional(),
+    localEndDate: z.string().nullable().optional(),
+    localStartDate: z.string().nullable().optional(),
     locationToDoorsMap: z
         .record(z.string(), z.array(z.string().nullable()).nullable())
         .nullable()
         .optional(),
-    name: z.string().nullable(),
-    updatedAtMillis: z.number().nullable(),
-})
-    .superRefine((value, ctx) => {
+    name: z.string().nullable().optional(),
+    updatedAtMillis: z.number().nullable().optional(),
+});
+export const CREATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA = DOOR_SCHEDULE_EXCEPTION_BASE_SCHEMA.superRefine((value, ctx) => {
     if (!value.name) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
@@ -74,6 +74,36 @@ export const DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA = z
         });
     }
 });
+export const UPDATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA = DOOR_SCHEDULE_EXCEPTION_BASE_SCHEMA.superRefine((value, ctx) => {
+    if (!value.uuid) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "exception.uuid is required for update-exception.",
+            path: ["uuid"],
+        });
+    }
+    const hasMutableField = [
+        value.name,
+        value.description,
+        value.defaultState,
+        value.localStartDate,
+        value.localEndDate,
+        value.intervals,
+        value.doorUuids,
+        value.locationToDoorsMap,
+    ].some((field) => field !== undefined);
+    if (!hasMutableField) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "exception update must provide at least one mutable field (for example name, description, dates, intervals, doorUuids, or locationToDoorsMap).",
+            path: [],
+        });
+    }
+});
+export const DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA = z.union([
+    CREATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA,
+    UPDATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA,
+]);
 export const TOOL_ARGS = {
     requestType: z
         .nativeEnum(DoorScheduleExceptionRequestType)

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

@@ -2,18 +2,21 @@ import { z } from "zod";
 import { createUuidSchema } from "../types.js";
 import DeviceType from "./deviceType.js";
 import { TempUnit } from "../utils/temp.js";
+const filterByObjectSchema = z.object({
+    locationUuids: z
+        .array(createUuidSchema())
+        .nullish()
+        .describe("The UUIDs of the locations to filter by. Set to null or an empty array to not filter by location."),
+});
 export const TOOL_ARGS = {
     entityTypes: z
         .array(z.nativeEnum(DeviceType).describe("The entity type to retreive"))
         .describe("What type of entities to retrieve."),
     filterBy: z
-        .object({
-        locationUuids: z
-            .array(createUuidSchema())
-            .nullable()
-            .describe("The UUIDs of the locations to filter by. Set to null or an enmpty array to not filter by location."),
-    })
-        .describe("Additional filters that can be applied to the result."),
+        .union([filterByObjectSchema, z.null()])
+        .optional()
+        .transform((v) => v ?? { locationUuids: null })
+        .describe("Additional filters that can be applied to the result. Omit or pass null for no filtering."),
     timeZone: z
         .string()
         .describe("The timezone for formatting timestamps. This is necessary for the tool to produce accurate formatted timestamps."),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhombus-node-mcp",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "MCP server for Rhombus API",
   "keywords": [
     "ai",