rhombus-node-mcp 0.1.13 → 0.1.16

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

@@ -1,117 +0,0 @@
-import { z } from "zod";
-import { postApi } from "../../network.js";
-import { createToolArgs, createToolTextContent } from "../../util.js";
-import DeviceType from "../../types/deviceType.js";
-async function getCameraList(requestModifiers) {
-    return {
-        cameras: (await postApi("/camera/getMinimalCameraStateList", "{}", requestModifiers)).cameraStates.filter((camera) => !!camera.locationUuid),
-    };
-}
-async function getDoorbellCameras(requestModifiers) {
-    return {
-        doorbellCameras: (await postApi("/doorbellcamera/getMinimalStateList", "{}", requestModifiers)).minimalStates.filter((doorbellCamera) => !!doorbellCamera.locationUuid),
-    };
-}
-async function getBadgeReaders(requestModifiers) {
-    return await postApi("/badgereader/getMinimalStateList", "{}", requestModifiers).then(response => {
-        return {
-            badgeReaders: response.minimalStates.filter((badgeReader) => !!badgeReader.locationUuid),
-        };
-    });
-}
-async function getAccessControlledDoors(requestModifiers) {
-    return await postApi("/component/findAccessControlledDoors", "{}", requestModifiers);
-}
-async function getAudioGateways(requestModifiers) {
-    return await postApi("/audiogateway/getMinimalAudioGatewayStateList", "{}", requestModifiers).then(response => {
-        return {
-            audioGateways: response.audioGatewayStates.filter((camera) => !!camera.locationUuid),
-        };
-    });
-}
-async function getDoorSensors(requestModifiers) {
-    return await postApi("/door/getMinimalDoorStateList", "{}", requestModifiers).then(response => {
-        return {
-            doorStates: response.doorStates.filter((door) => !!door.locationUuid),
-        };
-    });
-}
-async function getEnvironmentalSensors(requestModifiers) {
-    return await postApi("/climate/getMinimalClimateStateList", "{}", requestModifiers).then(response => {
-        return {
-            climateStates: response.climateStates.filter((sensor) => !!sensor.locationUuid),
-        };
-    });
-}
-async function getMotionSensors(requestModifiers) {
-    return await postApi("/occupancy/getMinimalOccupancySensorStateList", "{}", requestModifiers).then(response => {
-        return {
-            occupancySensorStates: response.occupancySensorStates.filter((occupancySensor) => !!occupancySensor.locationUuid),
-        };
-    });
-}
-async function getButtons(requestModifiers) {
-    return await postApi("/button/getMinimalButtonStateList", "{}", requestModifiers).then(response => {
-        return {
-            buttonStates: response.states.filter((button) => !!button.locationUuid),
-        };
-    });
-}
-async function getKeypads(requestModifiers) {
-    return await postApi("/keypad/getKeypadsForOrg", "{}", requestModifiers).then(response => {
-        return {
-            keypadStates: response.keypads.filter((keypad) => !!keypad.locationUuid),
-        };
-    });
-}
-export function createTool(server) {
-    server.tool("get-entity-tool", `
-    Retrieves entities (or devices) of certain types.
-    Can request multiple entity types at once.
-    The return structure is a JSON string that continues the states of the requested entities.
-    This data is exact. Whatever entities exist will be returned here.`, createToolArgs({
-        entityTypes: z
-            .array(z.nativeEnum(DeviceType).describe("The entity type to retreive"))
-            .describe("What type of entities to retrieve."),
-    }), async ({ entityTypes, requestModifiers }) => {
-        const promises = [];
-        if (entityTypes.includes(DeviceType.CAMERA)) {
-            promises.push(getCameraList(requestModifiers));
-        }
-        if (entityTypes.includes(DeviceType.DOORBELL_CAMERA)) {
-            promises.push(getDoorbellCameras(requestModifiers));
-        }
-        if (entityTypes.includes(DeviceType.BADGE_READER)) {
-            promises.push(getBadgeReaders(requestModifiers));
-        }
-        if (entityTypes.includes(DeviceType.ACCESS_CONTROL_DOOR)) {
-            promises.push(getAccessControlledDoors(requestModifiers));
-        }
-        if (entityTypes.includes(DeviceType.AUDIO_GATEWAY)) {
-            promises.push(getAudioGateways(requestModifiers));
-        }
-        if (entityTypes.includes(DeviceType.DOOR_SENSOR)) {
-            promises.push(getDoorSensors(requestModifiers));
-        }
-        if (entityTypes.includes(DeviceType.ENVIRONMENTAL_SENSOR)) {
-            promises.push(getEnvironmentalSensors(requestModifiers));
-        }
-        if (entityTypes.includes(DeviceType.MOTION_SENSOR)) {
-            promises.push(getMotionSensors(requestModifiers));
-        }
-        if (entityTypes.includes(DeviceType.BUTTON)) {
-            promises.push(getButtons(requestModifiers));
-        }
-        if (entityTypes.includes(DeviceType.KEYPAD)) {
-            promises.push(getKeypads(requestModifiers));
-        }
-        const responses = Promise.all(promises);
-        const ret = {
-            ...(await responses).reduce((prev, curr) => ({
-                ...prev,
-                ...curr
-            }), {})
-        };
-        return createToolTextContent(JSON.stringify(ret));
-    });
-}

package/dist/tools/get-org-information.js

@@ -1,18 +0,0 @@
-import { createToolArgs } from "../util.js";
-import { postApi } from "../network.js";
-async function getOrg(requestModifiers) {
-    return await postApi("/org/getOrgV2", {}, requestModifiers);
-}
-export function createTool(server) {
-    server.tool("get-org-information", "Get general information about the organization including org name, camera configuration defaults, contact information, and org settings.", createToolArgs({}), async ({ requestModifiers }) => {
-        const org = await getOrg(requestModifiers);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(org),
-                },
-            ],
-        };
-    });
-}

package/dist/tools/reboot-cameras.js

@@ -1,63 +0,0 @@
-import { z } from "zod";
-import { createToolArgs } from "../util.js";
-import { postApi } from "../network.js";
-import { addConfirmationParams, isConfirmed, requireConfirmation } from "../utils/confirmation.js";
-async function rebootCameras(cameraUuids, requestModifiers) {
-    let successCount = 0;
-    let errorCount = 0;
-    for (const cameraUuid in cameraUuids) {
-        try {
-            const body = { cameraUuid };
-            const response = await postApi("/camera/reboot", body, requestModifiers);
-            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 };
-    }
-}
-export function createTool(server) {
-    server.tool("reboot-cameras", "this tool is for rebooting one or more cameras causing them to reconnect to the server, this is a helpful option when a camera is experiencing connectivity issues or is in need of troubleshooting. THIS TOOL PERFORMS AN ACTION.", addConfirmationParams(createToolArgs({
-        cameraUuids: z
-            .array(z.string())
-            .describe("An array of camera UUID strings which are unique identifiers for cameras"),
-    })), async ({ cameraUuids, requestModifiers, confirmationId }) => {
-        const confirmation = requireConfirmation(confirmationId);
-        if (!isConfirmed(confirmation)) {
-            return confirmation;
-        }
-        const cameraRebootData = await rebootCameras(cameraUuids, requestModifiers);
-        if (!cameraRebootData) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Failed to reboot cameras",
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(cameraRebootData),
-                },
-            ],
-        };
-    });
-}