rhombus-node-mcp 0.1.11 → 0.1.13

package/dist/tools/reboot-cameras.js

@@ -0,0 +1,63 @@
+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),
+                },
+            ],
+        };
+    });
+}

package/dist/tools/time-tool.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { parse } from "chrono-node";
+import { DateTime } from "luxon";
+function nullToUndefined(value) {
+    return value === null ? undefined : value;
+}
+export function createTool(server) {
+    server.tool("time-tool", "Tool for converting a natural language time description into a timestamp in milliseconds.", {
+        time_description: z
+            .string()
+            .describe("A natural language description of the time (e.g., '2pm today', 'tomorrow at noon')."),
+        timezone: z
+            .string()
+            .optional()
+            .describe("Optional IANA timezone string (e.g., 'America/Los_Angeles', 'UTC'). Will default to system timezone if not provided."),
+    }, async ({ time_description, timezone }) => {
+        // console.error(`🕛 handling tool call for time ${time_description} using timezone ${timezone}`);
+        const now = DateTime.now()
+            .setZone(timezone || undefined)
+            .toJSDate();
+        const parsed = parse(time_description, now, { forwardDate: true });
+        if (!parsed || parsed.length === 0) {
+            throw new Error(`Could not parse time description: ${time_description}`);
+        }
+        const dateComponents = parsed[0].start;
+        if (!dateComponents) {
+            throw new Error("Parsed time has no start component");
+        }
+        const dt = DateTime.fromObject({
+            year: nullToUndefined(dateComponents.get("year")),
+            month: nullToUndefined(dateComponents.get("month")),
+            day: nullToUndefined(dateComponents.get("day")),
+            hour: nullToUndefined(dateComponents.get("hour")),
+            minute: nullToUndefined(dateComponents.get("minute")),
+            second: nullToUndefined(dateComponents.get("second")),
+            millisecond: 0,
+        }, {
+            zone: timezone || "local",
+        });
+        if (!dt.isValid) {
+            throw new Error(`Could not construct valid DateTime: ${dt.invalidReason}`);
+        }
+        const timestamp = dt.toMillis();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        timestamp,
+                        iso: dt.toISO(),
+                        timezone: dt.zoneName,
+                    }),
+                },
+            ],
+        };
+    });
+}

package/dist/types/deviceType.js

@@ -0,0 +1,14 @@
+var DeviceType;
+(function (DeviceType) {
+    DeviceType["CAMERA"] = "camera";
+    DeviceType["DOORBELL_CAMERA"] = "doorbell-camera";
+    DeviceType["BADGE_READER"] = "badge-reader";
+    DeviceType["ACCESS_CONTROL_DOOR"] = "access-control-door";
+    DeviceType["AUDIO_GATEWAY"] = "audio-gateway";
+    DeviceType["DOOR_SENSOR"] = "door-sensor";
+    DeviceType["ENVIRONMENTAL_SENSOR"] = "environmental-sensor";
+    DeviceType["MOTION_SENSOR"] = "motion-sensor";
+    DeviceType["BUTTON"] = "button";
+    DeviceType["KEYPAD"] = "keypad";
+})(DeviceType || (DeviceType = {}));
+export default DeviceType;

package/dist/types.js

@@ -1,19 +1,22 @@
 import { z } from "zod";
-export const CreateVideoWallOptions = z.optional(z.object({
-    displayName: z.optional(z.string()).describe("What to call the video wall"),
+export const UUID = z
+    .string()
+    .describe("This describes the UUID of some entity (device, location, etc.) and is unique and must come from data. This can not be fabricated. It is always 22 characters long");
+export const VideoWallSettings = z.object({
+    rowCount: z.number(),
+    columnCount: z.number(),
+    intervalSeconds: z.number().optional(),
+    rotateStrategy: z.enum(["none", "motion", "interval"]),
+});
+export const CreateVideoWallOptions = z
+    .object({
+    displayName: z.string().optional().describe("What to call the video wall"),
     orgUuid: z.string().describe("The uuid of the organization"),
     deviceList: z
         .array(z.string())
         .min(1)
         .describe("The list of camera uuids (unique identifiers) to exist in the video wall.  You must provide this manually by prompting the user at least once."),
-    othersCanEdit: z
-        .optional(z.boolean())
-        .default(false)
-        .describe("Whether or not other users can edit the wall, defaults to false"),
-    settings: z.object({
-        rowCount: z.number(),
-        columnCount: z.number(),
-        intervalSeconds: z.optional(z.number()),
-        rotateStrategy: z.enum(["none", "motion", "interval"]),
-    }),
-}));
+    othersCanEdit: z.boolean().optional().describe("Whether or not other users can edit the wall, defaults to false"),
+    settings: VideoWallSettings,
+})
+    .optional();

package/dist/util.js

@@ -0,0 +1,111 @@
+import { z } from "zod";
+import fs from "fs";
+import path from "path";
+export function generateRandomString(length) {
+    const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+const STATIC_ARGS = {
+    requestModifiers: z
+        .optional(z.object({
+        headers: z.nullable(z.record(z.string(), z.string())),
+        query: z.nullable(z.record(z.string(), z.string())),
+    }))
+        .describe("Optional headers accepted by tools.  LLM should never ever use this. 😅"),
+};
+/**
+ * Get all file paths in a directory in a directory
+ *
+ * i.e.
+ * foo:
+ *  - folder1:
+ *    - har
+ *    - gar
+ *  - bar
+ *  - lar
+ *
+ * returns: ["folder1/har", "folder1/gar", "bar", "lar"]
+ */
+export function getFilePathsInDirectory(dirPath) {
+    const filePaths = [];
+    const fileNames = fs.readdirSync(dirPath);
+    for (const fileName of fileNames) {
+        const pathToAdd = path.join(dirPath, fileName);
+        const stats = fs.lstatSync(pathToAdd);
+        if (stats.isDirectory()) {
+            filePaths.push(...getFilePathsInDirectory(pathToAdd));
+        }
+        else if (stats.isFile()) {
+            filePaths.push(pathToAdd);
+        }
+    }
+    return filePaths;
+}
+export function createToolArgs(args) {
+    return {
+        ...args,
+        ...STATIC_ARGS,
+    };
+}
+/**
+ * Returns an object in the form expected by `server.tool`
+ */
+export function createToolTextContent(content) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: content,
+            },
+        ],
+    };
+}
+/**
+ * Recursively removes fields with null values from a JavaScript object.
+ * If a nested object becomes empty after removing nulls, it will also be removed.
+ *
+ * @param {unknown} obj The object or array to clean.
+ * @returns {object | unknown[] | undefined} The cleaned object/array, or undefined if the input was null/undefined or an empty object/array resulted.
+ */
+export function removeNullFields(obj) {
+    if (obj === null || obj === undefined) {
+        return undefined;
+    }
+    if (Array.isArray(obj)) {
+        const cleanedArray = [];
+        for (const item of obj) {
+            const cleanedItem = removeNullFields(item);
+            if (cleanedItem !== undefined) {
+                cleanedArray.push(cleanedItem);
+            }
+        }
+        return cleanedArray.length > 0 ? cleanedArray : undefined;
+    }
+    if (typeof obj !== "object") {
+        return obj; // Cast to any for primitive types
+    }
+    const cleanedObject = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const value = obj[key];
+            if (value === null) {
+                continue;
+            }
+            if (typeof value === "object") {
+                const cleanedValue = removeNullFields(value);
+                if (cleanedValue !== undefined) {
+                    cleanedObject[key] = cleanedValue;
+                }
+            }
+            else {
+                cleanedObject[key] = value;
+            }
+        }
+    }
+    return Object.keys(cleanedObject).length > 0 ? cleanedObject : undefined;
+}

package/dist/utils/confirmation.js

@@ -0,0 +1,45 @@
+/**
+ * Confirmation is an important flow for our MCP, as letting an AI perform tools that change and mutate can be potentially dangerous
+ */
+import { z } from "zod";
+import { createToolTextContent, generateRandomString } from "../util.js";
+import { logger } from "../logger.js";
+// export function createToolArgs<TArgs extends object>(args: TArgs): TArgs & typeof STATIC_ARGS {
+//     return {
+//       ...args,
+//       ...STATIC_ARGS,
+//     };
+//   }
+export const CONFIRMATION_ARGS = {
+    confirmationId: z.string().nullable().optional(),
+};
+export function addConfirmationParams(args) {
+    return {
+        ...args,
+        ...CONFIRMATION_ARGS,
+    };
+}
+// IN MEMORY
+const confirmationStore = new Map();
+const CONFIRMATION_MAX_AGE = 15 * 60 * 1000; // 15 minutes
+export function requireConfirmation(confirmationId) {
+    // remove any old confirmations
+    for (const entry of confirmationStore) {
+        if (Date.now() - entry[1] > CONFIRMATION_MAX_AGE)
+            confirmationStore.delete(entry[0]);
+    }
+    logger.log("Checking for confirmationId:", confirmationId);
+    if (!confirmationId || !confirmationStore.has(confirmationId ?? "")) {
+        const newId = generateRandomString(8);
+        confirmationStore.set(newId, Date.now());
+        return createToolTextContent(JSON.stringify({
+            needUserInput: true,
+            description: `Please request confirmation for the user for performing this action. Upon confirmation, call this tool again with the confirmation id: ${newId}`,
+        }));
+    }
+    confirmationStore.delete(confirmationId);
+    return true;
+}
+export function isConfirmed(confirmation) {
+    return confirmation === true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhombus-node-mcp",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "MCP server for Rhombus API",
   "keywords": [
     "ai",
@@ -34,6 +34,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.9.0",
     "chrono-node": "^2.8.0",
+    "dotenv": "^16.5.0",
+    "log4js": "^6.9.1",
     "luxon": "^3.6.1",
     "zod": "^3.24.2"
   },