rhombus-node-mcp 0.1.23 → 0.1.26

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

@@ -0,0 +1,113 @@
+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 { createToolStructuredContent, createToolTextContent, extractFromToolExtra, } from "../util.js";
+const TOOL_NAME = "door-schedule-exception-tool";
+const TOOL_DESCRIPTION = `
+This tool manages Rhombus door schedule exceptions. 
+A door lock/unlock exception is a one-time rule used to change an access controlled door's locked/unlocked state. 
+If a lock/unlock exception is enabled, it will overwrite the existing lock/unlock schedule. 
+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.
+
+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.
+- ${DoorScheduleExceptionRequestType.FIND_EXCEPTIONS}: Find door schedule exceptions across the organization, optionally filtered by date range.
+- ${DoorScheduleExceptionRequestType.FIND_EXCEPTIONS_FOR_LOCATION}: Find door schedule exceptions for a location. Requires locationUuid. Supports optional date range filters.
+- ${DoorScheduleExceptionRequestType.FIND_EXCEPTIONS_FOR_DOOR}: Find door schedule exceptions for a door. Requires doorUuid. Supports optional date range filters.
+- ${DoorScheduleExceptionRequestType.GET_EXCEPTION}: Get a single door schedule exception by UUID. Requires exceptionUuid.
+- ${DoorScheduleExceptionRequestType.UPDATE_EXCEPTION}: Update a door schedule exception. Requires exception (DoorScheduleExceptionType object). If intervals are omitted but defaultState and date range are provided, the tool will generate a full-day interval.
+
+Use get-entity-tool to look up location and door UUIDs when needed.
+`;
+function buildDateRangeFilter(args) {
+    return {
+        localStartDateRangeStart: args.localStartDateRangeStart ?? undefined,
+        localStartDateRangeEnd: args.localStartDateRangeEnd ?? undefined,
+        localEndDateRangeStart: args.localEndDateRangeStart ?? undefined,
+        localEndDateRangeEnd: args.localEndDateRangeEnd ?? undefined,
+    };
+}
+const TOOL_HANDLER = async (args, _extra) => {
+    const { requestModifiers, sessionId } = extractFromToolExtra(_extra);
+    try {
+        switch (args.requestType) {
+            case DoorScheduleExceptionRequestType.CREATE_EXCEPTION: {
+                if (!args.exception) {
+                    return createToolTextContent(JSON.stringify({
+                        error: "exception is required for create-exception.",
+                    }));
+                }
+                const created = await createDoorScheduleException(args.exception, requestModifiers, sessionId);
+                return createToolStructuredContent(created);
+            }
+            case DoorScheduleExceptionRequestType.DELETE_EXCEPTION: {
+                if (!args.exceptionUuid) {
+                    return createToolTextContent(JSON.stringify({
+                        error: "exceptionUuid is required for delete-exception.",
+                    }));
+                }
+                const deleted = await deleteDoorScheduleException(args.exceptionUuid, requestModifiers, sessionId);
+                return createToolStructuredContent(deleted);
+            }
+            case DoorScheduleExceptionRequestType.FIND_EXCEPTIONS: {
+                const results = await findDoorScheduleExceptions(buildDateRangeFilter(args), requestModifiers, sessionId);
+                return createToolStructuredContent(results);
+            }
+            case DoorScheduleExceptionRequestType.FIND_EXCEPTIONS_FOR_LOCATION: {
+                if (!args.locationUuid) {
+                    return createToolTextContent(JSON.stringify({
+                        error: "locationUuid is required for find-exceptions-for-location.",
+                    }));
+                }
+                const results = await findDoorScheduleExceptionsForLocation(args.locationUuid, buildDateRangeFilter(args), requestModifiers, sessionId);
+                return createToolStructuredContent(results);
+            }
+            case DoorScheduleExceptionRequestType.FIND_EXCEPTIONS_FOR_DOOR: {
+                if (!args.doorUuid) {
+                    return createToolTextContent(JSON.stringify({
+                        error: "doorUuid is required for find-exceptions-for-door.",
+                    }));
+                }
+                const results = await findDoorScheduleExceptionsForDoor(args.doorUuid, buildDateRangeFilter(args), requestModifiers, sessionId);
+                return createToolStructuredContent(results);
+            }
+            case DoorScheduleExceptionRequestType.GET_EXCEPTION: {
+                if (!args.exceptionUuid) {
+                    return createToolTextContent(JSON.stringify({
+                        error: "exceptionUuid is required for get-exception.",
+                    }));
+                }
+                const exception = await getDoorScheduleException(args.exceptionUuid, requestModifiers, sessionId);
+                return createToolStructuredContent(exception);
+            }
+            case DoorScheduleExceptionRequestType.UPDATE_EXCEPTION: {
+                if (!args.exception) {
+                    return createToolTextContent(JSON.stringify({
+                        error: "exception is required for update-exception.",
+                    }));
+                }
+                const updated = await updateDoorScheduleException(args.exception, requestModifiers, sessionId);
+                return createToolStructuredContent(updated);
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return createToolStructuredContent({
+                error: error.message,
+            });
+        }
+        return createToolStructuredContent({
+            error: "Unknown error",
+        });
+    }
+    return createToolStructuredContent({ error: "Invalid request type" });
+};
+export function createTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS,
+        outputSchema: OUTPUT_SCHEMA.shape,
+    }, TOOL_HANDLER);
+}

package/dist/types/access-control-tool-types.js

@@ -13,7 +13,7 @@ export var AccessControlRequestType;
     AccessControlRequestType["GET_REMOTE_UNLOCK_USERS"] = "get-remote-unlock-users";
 })(AccessControlRequestType || (AccessControlRequestType = {}));
 export const TOOL_ARGS = {
-    requestType: z.nativeEnum(AccessControlRequestType).describe("The type of access control request to make."),
+    requestType: z.enum(AccessControlRequestType).describe("The type of access control request to make."),
     doorUuid: z
         .string()
         .nullable()

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

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { FILTER_BY_ARG, INCLUDE_FIELDS_ARG } from "../util.js";
+import { AccessControlledDoorStateEnumType } from "./schema.js";
+export var DoorScheduleExceptionRequestType;
+(function (DoorScheduleExceptionRequestType) {
+    DoorScheduleExceptionRequestType["CREATE_EXCEPTION"] = "create-exception";
+    DoorScheduleExceptionRequestType["DELETE_EXCEPTION"] = "delete-exception";
+    DoorScheduleExceptionRequestType["FIND_EXCEPTIONS"] = "find-exceptions";
+    DoorScheduleExceptionRequestType["FIND_EXCEPTIONS_FOR_LOCATION"] = "find-exceptions-for-location";
+    DoorScheduleExceptionRequestType["FIND_EXCEPTIONS_FOR_DOOR"] = "find-exceptions-for-door";
+    DoorScheduleExceptionRequestType["GET_EXCEPTION"] = "get-exception";
+    DoorScheduleExceptionRequestType["UPDATE_EXCEPTION"] = "update-exception";
+})(DoorScheduleExceptionRequestType || (DoorScheduleExceptionRequestType = {}));
+export const DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA = z
+    .object({
+    createdAtMillis: z.number().nullable(),
+    defaultState: z.enum(AccessControlledDoorStateEnumType).nullable(),
+    description: z.string().nullable(),
+    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(),
+    locationToDoorsMap: z
+        .record(z.string(), z.array(z.string().nullable()).nullable())
+        .nullable()
+        .optional(),
+    name: z.string().nullable(),
+    updatedAtMillis: z.number().nullable(),
+})
+    .superRefine((value, ctx) => {
+    if (!value.name) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "exception.name is required.",
+            path: ["name"],
+        });
+    }
+    if (!value.localStartDate) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "exception.localStartDate is required.",
+            path: ["localStartDate"],
+        });
+    }
+    if (!value.localEndDate) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "exception.localEndDate is required.",
+            path: ["localEndDate"],
+        });
+    }
+    if (!value.intervals || value.intervals.length === 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "exception.intervals must contain at least one interval.",
+            path: ["intervals"],
+        });
+    }
+    const hasDoorUuids = (value.doorUuids?.filter((doorUuid) => !!doorUuid).length ?? 0) > 0;
+    const hasLocationToDoorsMap = Object.values(value.locationToDoorsMap ?? {})
+        .flatMap((doorUuids) => doorUuids ?? [])
+        .some((doorUuid) => !!doorUuid);
+    if (!hasDoorUuids && !hasLocationToDoorsMap) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "exception must include at least one door in doorUuids or locationToDoorsMap.",
+            path: ["doorUuids"],
+        });
+    }
+});
+export const TOOL_ARGS = {
+    requestType: z
+        .nativeEnum(DoorScheduleExceptionRequestType)
+        .describe("The type of door schedule exception request to make."),
+    exceptionUuid: z
+        .string()
+        .nullable()
+        .describe("Door schedule exception UUID. Required for 'get-exception' and 'delete-exception'."),
+    locationUuid: z
+        .string()
+        .nullable()
+        .describe("Location UUID. Required for 'find-exceptions-for-location'."),
+    doorUuid: z
+        .string()
+        .nullable()
+        .describe("Door UUID. Required for 'find-exceptions-for-door'."),
+    exception: DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA.nullable().describe("DoorScheduleExceptionType object. Required for 'create-exception' and 'update-exception'."),
+    localStartDateRangeStart: z.iso
+        .datetime({ offset: true })
+        .optional()
+        .nullable()
+        .describe("Optional date range filter (inclusive) for local start date beginning (yyyy-MM-dd)."),
+    localStartDateRangeEnd: z.iso
+        .datetime({ offset: true })
+        .optional()
+        .nullable()
+        .describe("Optional date range filter (inclusive) for local start date end (yyyy-MM-dd)."),
+    localEndDateRangeStart: z.iso
+        .datetime({ offset: true })
+        .optional()
+        .nullable()
+        .describe("Optional date range filter (inclusive) for local end date beginning (yyyy-MM-dd)."),
+    localEndDateRangeEnd: z.iso
+        .datetime({ offset: true })
+        .optional()
+        .nullable()
+        .describe("Optional date range filter (inclusive) for local end date end (yyyy-MM-dd)."),
+    includeFields: INCLUDE_FIELDS_ARG,
+    filterBy: FILTER_BY_ARG,
+};
+const TOOL_ARGS_SCHEMA = z.object(TOOL_ARGS);
+const EXCEPTION_SCHEMA = z.object({
+    uuid: z.string().optional(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    locationUuid: z.string().optional(),
+    localStartDate: z.string().optional(),
+    localEndDate: z.string().optional(),
+    defaultState: z.string().optional(),
+    doorUuids: z.array(z.string()).optional(),
+    intervalCount: z.number().optional(),
+    createdAtMillis: z.number().optional(),
+    updatedAtMillis: z.number().optional(),
+});
+export const OUTPUT_SCHEMA = z.object({
+    exception: EXCEPTION_SCHEMA.optional().describe("Single door schedule exception result."),
+    exceptions: z
+        .array(EXCEPTION_SCHEMA)
+        .optional()
+        .describe("List of door schedule exceptions."),
+    deleted: z
+        .object({
+        success: z.boolean().optional(),
+        exceptionUuid: z.string().optional(),
+    })
+        .optional()
+        .describe("Delete result."),
+    expiredACDLicensesDoorUuids: z
+        .array(z.string())
+        .optional()
+        .describe("Door UUIDs with expired access control licenses."),
+    unassignedACDLicensesDoorUuids: z
+        .array(z.string())
+        .optional()
+        .describe("Door UUIDs with unassigned access control licenses."),
+    warningMsg: z
+        .string()
+        .optional()
+        .describe("Warning returned by backend, if any."),
+    error: z
+        .string()
+        .optional()
+        .describe("An error message if the request failed."),
+});

package/dist/types/report-tool-types.js

@@ -263,7 +263,7 @@ export const SanitizedTimeSeriesDataPoint = z.object({
     dateUtcString: z
         .optional(z.string())
         .describe("The UTC date of the data point in ISO 8601 format"),
-    eventCountMap: z.optional(z.record(z.any())),
+    eventCountMap: z.optional(z.record(z.string(), z.any())),
 });
 const FaceCountEnrichment = z.object({
     uniqueFaceCount: z.number().describe("Number of unique people identified by face recognition in the same time range"),
@@ -299,12 +299,12 @@ export const OUTPUT_SCHEMA = z.object({
         error: z.optional(z.boolean()),
         errorMsg: z.optional(z.string()),
         timeSeriesDataPoints: z.optional(z.array(z.object({
-            approximateTimestampMsMap: z.optional(z.record(z.unknown())),
+            approximateTimestampMsMap: z.optional(z.record(z.string(), z.unknown())),
             dateLocal: z.optional(z.string()),
             dateUtc: z.optional(z.string()),
             dateLocalString: z.optional(z.string()),
             dateUtcString: z.optional(z.string()),
-            eventCountMap: z.optional(z.record(z.unknown())),
+            eventCountMap: z.optional(z.record(z.string(), z.unknown())),
             timestampMs: z.optional(z.number()),
         }))),
         faceCountEnrichment: z
@@ -328,7 +328,7 @@ export const OUTPUT_SCHEMA = z.object({
             name: z.optional(z.string()),
             serialNumber: z.optional(z.string()),
             locationUuid: z.optional(z.string()),
-            facetNameMap: z.optional(z.record(z.string().nullable())),
+            facetNameMap: z.optional(z.record(z.string(), z.string().nullable())),
             deleted: z.optional(z.boolean()),
             pending: z.optional(z.boolean()),
             mummified: z.optional(z.boolean()),
@@ -340,7 +340,7 @@ export const OUTPUT_SCHEMA = z.object({
         .optional(z.object({
         error: z.optional(z.boolean()),
         errorMsg: z.optional(z.string()),
-        camerasToConfigs: z.optional(z.record(z.unknown())),
+        camerasToConfigs: z.optional(z.record(z.string(), z.unknown())),
     }))
         .nullable()
         .describe("Cameras at a location that have line crossing enabled with their configurations"),
@@ -438,7 +438,7 @@ export const OUTPUT_SCHEMA = z.object({
         timeSeriesDataPoints: z.optional(z.array(z.object({
             dateLocal: z.optional(z.string()),
             dateUtc: z.optional(z.string()),
-            eventCountMap: z.optional(z.record(z.union([z.number(), z.boolean(), z.string()]))),
+            eventCountMap: z.optional(z.record(z.string(), z.union([z.number(), z.boolean(), z.string()]))),
         }))),
     }))
         .nullable()
@@ -492,7 +492,7 @@ export const OUTPUT_SCHEMA = z.object({
         timeSeriesDataPoints: z.optional(z.array(z.object({
             dateLocal: z.optional(z.string()),
             dateUtc: z.optional(z.string()),
-            eventCountMap: z.optional(z.record(z.any())),
+            eventCountMap: z.optional(z.record(z.string(), z.any())),
         }))),
     }))
         .describe("Custom events report time series"),

package/dist/types/user-tool-types.js

@@ -44,7 +44,7 @@ export const OUTPUT_SCHEMA = z.object({
     permissions: z
         .object({
         role: z.string().optional(),
-        functionalityAccessMap: z.record(z.string()).optional(),
+        functionalityAccessMap: z.record(z.string(), z.string()).optional(),
     })
         .optional()
         .describe("Current user permissions"),