rhombus-node-mcp 0.1.22 → 0.1.24

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

@@ -0,0 +1,78 @@
+import { postApi } from "../network.js";
+export async function listRules(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/rules/getRulesForOrg",
+        body: {},
+        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,
+        enabled: rule.enabled ?? undefined,
+        orgUuid: rule.orgUuid ?? undefined,
+        ruleType: rule.ruleType ?? undefined,
+        createdAtMs: rule.createdAtMs ?? undefined,
+        updatedAtMs: rule.updatedAtMs ?? undefined,
+    })) ?? []);
+}
+export async function createRule(ruleConfig, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/rules/createRule",
+        body: ruleConfig,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return {
+        uuid: res.ruleUuid ?? undefined,
+        success: true,
+    };
+}
+export async function updateRule(ruleConfig, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/rules/updateRule",
+        body: ruleConfig,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return { success: true };
+}
+export async function deleteRule(ruleUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/rules/deleteRule",
+        body: { ruleUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return { uuid: ruleUuid, success: true };
+}
+export async function getRuleRecords(ruleUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/rulesRecords/getRulesEventRecords",
+        body: { ruleUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.rulesEventRecords?.map((record) => ({
+        uuid: record.uuid ?? undefined,
+        ruleUuid: record.ruleUuid ?? undefined,
+        triggeredAtMs: record.triggeredAtMs ?? undefined,
+        deviceUuid: record.deviceUuid ?? undefined,
+        locationUuid: record.locationUuid ?? undefined,
+    })) ?? []);
+}

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

@@ -0,0 +1,93 @@
+import { postApi } from "../network.js";
+export async function searchLicensePlates(query, startTimeMs, endTimeMs, deviceUuids, locationUuids, requestModifiers, sessionId) {
+    const body = {
+        licensePlate: query,
+        startTime: startTimeMs,
+        endTime: endTimeMs,
+        deviceUuids: deviceUuids ?? undefined,
+        locationUuids: locationUuids ?? undefined,
+    };
+    const res = await postApi({
+        route: "/search/searchLicensePlates",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.vehicleEvents?.map((event) => ({
+        licensePlate: event.vehicleLicensePlate ?? undefined,
+        deviceUuid: event.deviceUuid ?? undefined,
+        timestampMs: event.eventTimestamp ?? undefined,
+        confidence: event.confidence ?? undefined,
+    })) ?? []);
+}
+export async function searchObjectsByColor(color, cameraUuid, startTimeMs, endTimeMs, requestModifiers, sessionId) {
+    const body = {
+        colorFilter: [color],
+        deviceFilter: [cameraUuid],
+        startTimeMs: startTimeMs,
+        endTimeMs: endTimeMs,
+    };
+    const res = await postApi({
+        route: "/search/searchObjectsByColor",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.objects?.map((result) => ({
+        deviceUuid: result.deviceUuid ?? undefined,
+        timestampMs: result.timestampMs ?? undefined,
+        objectType: result.objectType ?? undefined,
+        color: result.color ?? undefined,
+    })) ?? []);
+}
+export async function searchObjectsByText(textQuery, startTimeMs, endTimeMs, deviceUuids, requestModifiers, sessionId) {
+    const body = {
+        searchText: textQuery,
+        model: "CLIP_512",
+        queryStartTimeMs: startTimeMs,
+        queryEndTimeMs: endTimeMs,
+        queryDeviceUuids: deviceUuids ?? [],
+        maxNumResults: 100,
+        similarityThreshold: 0.5,
+    };
+    const res = await postApi({
+        route: "/search/searchSimilarObjectEmbeddingsByText",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.similarEmbeddings?.map((match) => ({
+        deviceUuid: match.embedding?.deviceUuid ?? undefined,
+        timestampMs: match.embedding?.timestamp ?? undefined,
+        score: match.distance ?? undefined,
+    })) ?? []);
+}
+export async function searchMotionGrid(cameraUuid, startTimeMs, endTimeMs, requestModifiers, sessionId) {
+    const body = {
+        deviceUuid: cameraUuid,
+        startTimeUtcSecs: Math.floor(startTimeMs / 1000),
+        endTimeUtcSecs: Math.floor(endTimeMs / 1000),
+        searchCells: [],
+    };
+    const res = await postApi({
+        route: "/event/searchMotionGrid",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.timeUtcSecsList?.map((ts) => ({
+        timestampSecs: ts,
+    })) ?? []);
+}

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

@@ -21,7 +21,9 @@ function normalizeTimeDescription(description) {
     }
     // Handle "this" time periods - always refer to today
     if (normalized === "this morning") {
-        return "today at 06:00";
+        // For occupancy/access-control investigations, "this morning" should include
+        // all events since local midnight unless a narrower range is explicitly requested.
+        return "today at 00:00";
     }
     if (normalized === "this afternoon") {
         return "today at 12:00";

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

@@ -59,6 +59,210 @@ export async function getCameraDetails(cameraUuid, requestModifiers, sessionId)
         };
     }
 }
+async function getCameraHardwareVariation(cameraUuid, requestModifiers, sessionId) {
+    try {
+        const result = await postApi({
+            route: "/camera/getDetails",
+            body: {
+                cameraUuids: [cameraUuid],
+            },
+            modifiers: requestModifiers,
+            sessionId,
+        });
+        if (result.error) {
+            return {
+                success: false,
+                error: result.errorMsg || "Failed to get camera hardware variation",
+            };
+        }
+        const camera = result.cameras?.[0];
+        return {
+            success: true,
+            hwVariation: camera?.hwVariation ?? undefined,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error occurred",
+        };
+    }
+}
+async function getOrgCameraConfigOptions(requestModifiers, sessionId) {
+    try {
+        const result = await postApi({
+            route: "/org/getOrgV2",
+            body: {},
+            modifiers: requestModifiers,
+            sessionId,
+        });
+        if (result.error) {
+            return {
+                success: false,
+                error: result.errorMsg || "Failed to get organization camera config options",
+            };
+        }
+        return {
+            success: true,
+            cameraConfigOptions: result.cameraConfigOptions ?? undefined,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error occurred",
+        };
+    }
+}
+async function getCameraFacetedConfig(cameraUuid, requestModifiers, sessionId) {
+    try {
+        const result = await postApi({
+            route: "/camera/getFacetedConfig",
+            body: {
+                deviceUuid: cameraUuid,
+            },
+            modifiers: requestModifiers,
+            sessionId,
+        });
+        if (result.error) {
+            return {
+                success: false,
+                error: result.errorMsg || "Failed to get camera faceted config",
+            };
+        }
+        return {
+            success: true,
+            config: result.config,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error occurred",
+        };
+    }
+}
+export async function validateCameraFeatureSupport(payload, requestModifiers, sessionId) {
+    const requestedVideoSettings = Object.values(payload.configUpdate.videoFacetSettings ?? {});
+    const requestedAudioSettings = Object.values(payload.configUpdate.audioFacetSettings ?? {});
+    const requestedDeviceSettings = payload.configUpdate.deviceSettings;
+    if (requestedVideoSettings.length === 0 &&
+        requestedAudioSettings.length === 0 &&
+        !requestedDeviceSettings) {
+        return { canProceed: true };
+    }
+    const requestedFacet = Object.keys(payload.configUpdate.videoFacetSettings ?? {})[0] ??
+        Object.keys(payload.configUpdate.audioFacetSettings ?? {})[0] ??
+        "v0";
+    const requestedVideoSettingsForFacet = requestedVideoSettings[0];
+    const requestedAudioSettingsForFacet = requestedAudioSettings[0];
+    const requestedWdrStrength = requestedVideoSettings
+        .map(settings => settings.wdr_strength)
+        .find(value => value !== undefined && value !== null);
+    const hasWdrRequest = requestedVideoSettings.some(settings => settings.wdr_enabled !== undefined || settings.wdr_strength !== undefined);
+    const requestedResolution = requestedVideoSettingsForFacet?.resolution;
+    const hasResolutionRequest = requestedResolution?.width !== undefined && requestedResolution?.height !== undefined;
+    const hasAudioRequest = requestedAudioSettings.length > 0;
+    const [hardwareVariationResult, orgOptionsResult, facetedConfigResult] = await Promise.all([
+        getCameraHardwareVariation(payload.configUpdate.deviceUuid, requestModifiers, sessionId),
+        getOrgCameraConfigOptions(requestModifiers, sessionId),
+        getCameraFacetedConfig(payload.configUpdate.deviceUuid, requestModifiers, sessionId),
+    ]);
+    if (facetedConfigResult.success && facetedConfigResult.config) {
+        const videoFacetConfig = facetedConfigResult.config.videoFacetSettings?.[requestedFacet];
+        const audioFacetConfig = facetedConfigResult.config.audioFacetSettings?.[requestedFacet];
+        const deviceConfig = facetedConfigResult.config.deviceSettings;
+        if (hasAudioRequest && audioFacetConfig?.audio_supported === false) {
+            return {
+                canProceed: false,
+                error: "This camera does not support audio features.",
+            };
+        }
+        const unsupportedVideoFields = getUnsupportedFieldsFromSetMethodMap(requestedVideoSettingsForFacet, videoFacetConfig?.updatedSetMethodMap);
+        if (unsupportedVideoFields.length > 0) {
+            return {
+                canProceed: false,
+                error: `This camera does not support updating video setting: ${unsupportedVideoFields[0]}.`,
+            };
+        }
+        const unsupportedAudioFields = getUnsupportedFieldsFromSetMethodMap(requestedAudioSettingsForFacet, audioFacetConfig?.updatedSetMethodMap);
+        if (unsupportedAudioFields.length > 0) {
+            return {
+                canProceed: false,
+                error: `This camera does not support updating audio setting: ${unsupportedAudioFields[0]}.`,
+            };
+        }
+        const unsupportedDeviceFields = getUnsupportedFieldsFromSetMethodMap(requestedDeviceSettings, deviceConfig?.updatedSetMethodMap);
+        if (unsupportedDeviceFields.length > 0) {
+            return {
+                canProceed: false,
+                error: `This camera does not support updating device setting: ${unsupportedDeviceFields[0]}.`,
+            };
+        }
+    }
+    // Model-level capability metadata can be unavailable on some deployments; do not hard-fail.
+    if (!hardwareVariationResult.success || !orgOptionsResult.success) {
+        return { canProceed: true };
+    }
+    const hwVariation = hardwareVariationResult.hwVariation;
+    if (!hwVariation) {
+        return { canProceed: true };
+    }
+    const cameraOptions = orgOptionsResult.cameraConfigOptions?.[hwVariation];
+    if ((!hasWdrRequest && !hasResolutionRequest) ||
+        !Array.isArray(cameraOptions) ||
+        cameraOptions.length === 0) {
+        return { canProceed: true };
+    }
+    if (hasWdrRequest) {
+        const wdrOption = cameraOptions.find(option => option?.wdrRange !== undefined);
+        if (!wdrOption?.wdrRange) {
+            return {
+                canProceed: false,
+                error: "This camera does not support WDR feature.",
+            };
+        }
+        if (typeof requestedWdrStrength === "number") {
+            const min = wdrOption.wdrRange.min;
+            const max = wdrOption.wdrRange.max;
+            if (typeof min === "number" && requestedWdrStrength < min) {
+                return {
+                    canProceed: false,
+                    error: `This camera supports WDR, but wdr_strength=${requestedWdrStrength} is below the supported minimum (${min}).`,
+                };
+            }
+            if (typeof max === "number" && requestedWdrStrength > max) {
+                return {
+                    canProceed: false,
+                    error: `This camera supports WDR, but wdr_strength=${requestedWdrStrength} exceeds the supported maximum (${max}).`,
+                };
+            }
+        }
+    }
+    if (hasResolutionRequest) {
+        const isRequestedResolutionSupported = cameraOptions.some(option => {
+            const optionWidth = option?.resolution?.width;
+            const optionHeight = option?.resolution?.height;
+            return (typeof optionWidth === "number" &&
+                typeof optionHeight === "number" &&
+                optionWidth === requestedResolution.width &&
+                optionHeight === requestedResolution.height);
+        });
+        if (!isRequestedResolutionSupported) {
+            return {
+                canProceed: false,
+                error: `This camera does not support resolution ${requestedResolution.width}x${requestedResolution.height}.`,
+            };
+        }
+    }
+    return { canProceed: true };
+}
+function getUnsupportedFieldsFromSetMethodMap(requestedSettings, setMethodMap) {
+    if (!requestedSettings || !setMethodMap) {
+        return [];
+    }
+    return Object.keys(requestedSettings).filter(field => setMethodMap[field] === false);
+}
 /**
  * Helper function to remove null/undefined fields from update payload
  */

package/dist/api/user-access-trail-tool-api.js

@@ -0,0 +1,45 @@
+import { postApi } from "../network.js";
+export async function resolveUserUuid(email, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/user/findUserByEmail",
+        body: { email },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(res.errorMsg ?? "Failed to find user by email");
+    }
+    const user = res.user;
+    if (!user?.uuid) {
+        throw new Error(`No user found with email: ${email}`);
+    }
+    const name = [user.firstName, user.lastName].filter(Boolean).join(" ") || undefined;
+    return { uuid: user.uuid, name };
+}
+export async function getAccessEventsByUser(userUuid, startTimeMs, endTimeMs, limit, requestModifiers, sessionId) {
+    const body = {
+        userUuid,
+        limit: limit ?? 100,
+    };
+    if (startTimeMs)
+        body.createdAfterMs = startTimeMs;
+    if (endTimeMs)
+        body.createdBeforeMs = endTimeMs;
+    const res = await postApi({
+        route: "/component/findComponentEventsByUser",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    const events = res.componentEvents ?? [];
+    return events.map((evt) => ({
+        eventUuid: evt.uuid ?? undefined,
+        eventType: evt.type ?? undefined,
+        timestampMs: evt.timestampMs ?? evt.createdAtMs ?? undefined,
+        locationUuid: evt.locationUuid ?? undefined,
+        componentUuid: evt.componentUuid ?? undefined,
+        ownerDeviceUuid: evt.ownerDeviceUuid ?? undefined,
+        authorizationResult: evt.authorizationResult ?? undefined,
+        authenticationResult: evt.authenticationResult ?? undefined,
+    }));
+}

package/dist/api/user-audit-tool-api.js

@@ -0,0 +1,47 @@
+import { postApi } from "../network.js";
+function mapAuditEvents(events) {
+    return events.map(evt => ({
+        uuid: evt.uuid ?? undefined,
+        action: evt.action ?? undefined,
+        displayText: evt.displayText ?? undefined,
+        principalName: evt.principalName ?? undefined,
+        principalUuid: evt.principalUuid ?? undefined,
+        targetName: evt.targetName ?? undefined,
+        targetUuid: evt.targetUuid ?? undefined,
+        timestamp: evt.timestamp ?? undefined,
+        failure: evt.failure ?? undefined,
+        sourceIp: evt.sourceIp ?? undefined,
+        sourceCity: evt.sourceCity ?? undefined,
+        sourceCountry: evt.sourceCountry ?? undefined,
+    }));
+}
+export async function getAuditFeedForPrincipal(principalUuid, maxResults, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/report/getAuditFeedForPrincipal",
+        body: {
+            principalUuid,
+            maxResults: maxResults ?? 50,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(res.errorMsg ?? "Failed to get audit feed for principal");
+    }
+    return mapAuditEvents(res.auditEvents ?? []);
+}
+export async function getAuditFeedForTarget(targetUuid, maxResults, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/report/getAuditFeedForTarget",
+        body: {
+            targetUuid,
+            maxResults: maxResults ?? 50,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(res.errorMsg ?? "Failed to get audit feed for target");
+    }
+    return mapAuditEvents(res.auditEvents ?? []);
+}

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

@@ -0,0 +1,77 @@
+import { postApi } from "../network.js";
+export async function listUsers(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/user/getUsersInOrg",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.users?.map(user => ({
+        uuid: user.uuid ?? undefined,
+        email: user.email ?? undefined,
+        firstName: user.firstName ?? undefined,
+        lastName: user.lastName ?? undefined,
+    })) ?? []);
+}
+export async function findUserByEmail(email, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/user/findUserByEmail",
+        body: { email },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    const user = res.user;
+    if (!user)
+        return undefined;
+    return {
+        uuid: user.uuid ?? undefined,
+        email: user.email ?? undefined,
+        firstName: user.firstName ?? undefined,
+        lastName: user.lastName ?? undefined,
+        role: user.roleUuid ?? undefined,
+        orgUuid: user.orgUuid ?? undefined,
+        lastLoginMs: user.lastLoginMs ?? undefined,
+        enabled: user.enabled ?? undefined,
+        mfaEnabled: user.mfaEnabled ?? undefined,
+    };
+}
+export async function getPermissionsForCurrentUser(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/permission/getPermissionsForCurrentUser",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return {
+        role: res.role ?? undefined,
+        functionalityAccessMap: res.functionalityAccessMap
+            ? Object.fromEntries(Object.entries(res.functionalityAccessMap).map(([k, v]) => [k, String(v)]))
+            : undefined,
+    };
+}
+export async function getPermissionGroups(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/permission/getPermissionGroupsForOrg",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.permissionGroups?.map(group => ({
+        uuid: group.uuid ?? undefined,
+        name: group.name ?? undefined,
+        orgUuid: group.orgUuid ?? undefined,
+        role: group.role ?? undefined,
+    })) ?? []);
+}

package/dist/createServer.js

@@ -1,5 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { logger } from "./logger.js";
+import { createFilteringProxy } from "./util.js";
 import getResources from "./resources/getResources.js";
 import getTools from "./tools/getTools.js";
 let initiated = false;
@@ -35,9 +36,10 @@ export default async function createServer() {
         resource.create(server);
     }
     logger.info(`🛠️ Registered ${resources.length} resources`);
+    const filteredServer = createFilteringProxy(server, new Set(["time-tool", "count-tool", "time-conversion-tool"]));
     for (const tool of tools) {
         try {
-            await tool.create(server);
+            await tool.create(filteredServer);
         }
         catch (error) {
             logger.error(`Failed to register tool ${tool.name}:`, error);