rhombus-node-mcp 0.1.8 → 0.1.10

package/dist/index.js

@@ -2,6 +2,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
+import { CreateVideoWallOptions } from "./types.js";
+import { parse } from "chrono-node";
+import { DateTime } from "luxon";
 const THREE_HOURS_MS = 3 * 60 * 60 * 1000;
 const FIVE_SECONDS_MS = 5 * 1000;
 const RHOMBUS_API_KEY = process.env.RHOMBUS_API_KEY;
@@ -9,15 +12,17 @@ if (!RHOMBUS_API_KEY) {
     console.error("Missing RHOMBUS_API_KEY");
 }
 const enableLogs = process.env.ENABLE_LOGS;
-const BASE_URL = "https://api2.rhombussystems.com/api";
+const serverUrl = process.env.RHOMBUS_API_SERVER || "api2.rhombussystems.com";
+console.error("🌐 Using server url", serverUrl);
+const BASE_URL = `https://${serverUrl}/api`;
 const STATIC_HEADERS = {
     "Content-Type": "application/json",
+    "x-rhombus-agent": "chatbot",
     accept: "application/json",
 };
 const AUTH_HEADERS = {
     "x-auth-apikey": RHOMBUS_API_KEY,
     "x-auth-scheme": "api-token",
-    "x-rhombus-agent": "chatbot",
 };
 const server = new McpServer({
     name: "rhombus",
@@ -28,8 +33,11 @@ const server = new McpServer({
     },
 });
 const STATIC_ARGS = {
-    headers: z
-        .optional(z.any())
+    requestModifiers: z
+        .optional(z.object({
+        headers: z.optional(z.any()),
+        query: z.optional(z.any()),
+    }))
         .describe("Optional headers accepted by tools.  LLM should never ever use this. 😅"),
 };
 const log = (msg) => {
@@ -37,16 +45,34 @@ const log = (msg) => {
         return;
     console.error(msg);
 };
-async function postApi(url, body, customHeaders) {
-    let headers = {
-        ...(customHeaders || AUTH_HEADERS),
+const appendQueryParams = (url, params) => {
+    if (!params || typeof params !== "object")
+        return url;
+    const urlObj = new URL(url);
+    const existingSearchParams = new URLSearchParams(urlObj.search);
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null) {
+            existingSearchParams.append(key, String(value));
+        }
+    }
+    const baseUrl = url.split("?")[0];
+    const queryString = existingSearchParams.toString();
+    return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+};
+async function postApi(url, body, modifiers) {
+    let requestHeaders = {
+        ...(modifiers?.headers || AUTH_HEADERS),
         ...STATIC_HEADERS,
     };
+    if (modifiers?.query) {
+        url = appendQueryParams(url, modifiers.query);
+    }
     try {
-        log(`[POSTAPI] REQUEST - ${url} - ${body} - ${JSON.stringify(customHeaders)}`);
-        const response = await fetch(url, { method: "POST", headers, body });
-        log(`[POSTAPI] RESPONSE - ${JSON.stringify(response || {})}`);
+        log(`[POSTAPI] REQUEST - ${url} - ${body} - ${JSON.stringify(requestHeaders)}`);
+        const response = await fetch(url, { method: "POST", headers: requestHeaders, body });
+        log(`[POSTAPI] RESPONSE - ${JSON.stringify(response)}`);
         if (!response.ok) {
+            log(`❌ RESPONSE - ${response.ok} - ${response.status}`);
             if (response.status === 401 || response.status === 403) {
                 return {
                     error: true,
@@ -55,36 +81,39 @@ async function postApi(url, body, customHeaders) {
             }
             throw new Error(`HTTP error! status: ${response.status}`);
         }
-        return await response.json();
+        const ret = await response.json();
+        log(`❌ RESPONSE - ${response.ok} - ${JSON.stringify(ret)}`);
+        return ret;
     }
     catch (error) {
+        log(`[POSTAPI] ERROR - ${JSON.stringify(error || {})}`);
         return {
             error: true,
             status: `Request Error: ${error}`,
         };
     }
 }
-async function getOrg(headers) {
+async function getOrg(requestModifiers) {
     const url = BASE_URL + "/org/getOrgV2";
-    return await postApi(url, "{}", headers);
+    return await postApi(url, "{}", requestModifiers);
 }
-async function getLocations(headers) {
+async function getLocations(requestModifiers) {
     const url = BASE_URL + "/location/getLocationsV2";
-    return await postApi(url, "{}", headers);
+    return await postApi(url, "{}", requestModifiers);
 }
-async function getCameraList(headers) {
+async function getCameraList(requestModifiers) {
     const url = BASE_URL + "/camera/getMinimalCameraStateList";
-    return await postApi(url, "{}", headers).then(response => {
+    return await postApi(url, "{}", requestModifiers).then(response => {
         return {
             cameraStates: response.cameraStates.filter((camera) => !!camera.locationUuid),
         };
     });
 }
-async function getAccessControlledDoors(headers) {
+async function getAccessControlledDoors(requestModifiers) {
     const url = BASE_URL + "/component/findAccessControlledDoors";
-    return await postApi(url, "{}", headers);
+    return await postApi(url, "{}", requestModifiers);
 }
-async function getFaceEvents(_locationUuid, headers) {
+async function getFaceEvents(_locationUuid, requestModifiers) {
     const nowMs = Date.now();
     const rangeStartMs = nowMs - THREE_HOURS_MS;
     const rangeEndMs = nowMs - FIVE_SECONDS_MS;
@@ -105,7 +134,7 @@ async function getFaceEvents(_locationUuid, headers) {
             },
         },
     });
-    const response = await postApi(BASE_URL + "/faceRecognition/faceEvent/findFaceEventsByOrg", body, headers).then(response => {
+    const response = await postApi(BASE_URL + "/faceRecognition/faceEvent/findFaceEventsByOrg", body, requestModifiers).then(response => {
         return {
             faceEvents: (response.faceEvents || []).map((event) => ({
                 ...event,
@@ -115,13 +144,13 @@ async function getFaceEvents(_locationUuid, headers) {
     });
     return response;
 }
-async function getAccessControlEvents(doorUuid, headers) {
+async function getAccessControlEvents(doorUuid, requestModifiers) {
     const url = BASE_URL + "/component/findComponentEventsByAccessControlledDoor";
     const body = JSON.stringify({
         limit: 50,
         accessControlledDoorUuid: doorUuid,
     });
-    const response = await postApi(url, body, headers).then(response => ({
+    const response = await postApi(url, body, requestModifiers).then(response => ({
         componentEvents: (response.componentEvents || []).map((event) => ({
             ...event,
             timestamp: new Date(event.timestampMs).toString(),
@@ -129,14 +158,14 @@ async function getAccessControlEvents(doorUuid, headers) {
     }));
     return response;
 }
-async function rebootCameras(cameraUuids, headers) {
+async function rebootCameras(cameraUuids, requestModifiers) {
     const url = BASE_URL + "/camera/reboot";
     let successCount = 0;
     let errorCount = 0;
     for (const cameraUuid in cameraUuids) {
         try {
             const body = JSON.stringify({ cameraUuid: cameraUuid });
-            const response = await postApi(url, body, headers);
+            const response = await postApi(url, body, requestModifiers);
             if (response.error) {
                 errorCount++;
             }
@@ -158,7 +187,26 @@ async function rebootCameras(cameraUuids, headers) {
         return { status, successCount, errorCount };
     }
 }
-async function getImageForCameraAtTime(cameraUuid, timestampMs, headers) {
+async function createVideoWall(options, headers) {
+    const url = BASE_URL + "/camera/createVideoWall";
+    const body = JSON.stringify({
+        videoWall: {
+            displayName: options?.displayName,
+            deviceList: options?.deviceList,
+            othersCanEdit: true,
+            orgUuid: options?.orgUuid,
+            shared: true,
+            settings: {
+                gridSize: { width: options?.settings.columnCount, height: options?.settings.columnCount },
+                gridLayout: "1 2\n3 4",
+                intervalSeconds: options?.settings.intervalSeconds || 5,
+            },
+        },
+    });
+    const response = await postApi(url, body, headers);
+    return response;
+}
+async function getImageForCameraAtTime(cameraUuid, timestampMs, requestModifiers) {
     const url = BASE_URL + "/video/getExactFrameUri";
     const body = JSON.stringify({
         cameraUuid: cameraUuid,
@@ -170,8 +218,12 @@ async function getImageForCameraAtTime(cameraUuid, timestampMs, headers) {
         permyriadCropY: 0,
         timestampMs: timestampMs,
     });
-    const base64Image = await postApi(url, body, headers).then(async (res) => {
-        return await fetch(res.frameUri, { method: "GET", headers: headers }).then(async (res) => {
+    const base64Image = await postApi(url, body, requestModifiers).then(async (res) => {
+        let requestHeaders = {
+            ...(requestModifiers?.headers || AUTH_HEADERS),
+            ...STATIC_HEADERS,
+        };
+        return await fetch(res.frameUri, { method: "GET", headers: requestHeaders }).then(async (res) => {
             if (!res.ok)
                 return null;
             const arrayBuffer = await res.arrayBuffer();
@@ -193,8 +245,8 @@ async function getImageForCameraAtTime(cameraUuid, timestampMs, headers) {
         imageData: base64Image,
     };
 }
-server.tool("get-org-information", "Get general information about the organization including org name, camera configuration defaults, contact information, and org settings.", { ...STATIC_ARGS }, async ({ headers }) => {
-    const org = await getOrg(headers);
+server.tool("get-org-information", "Get general information about the organization including org name, camera configuration defaults, contact information, and org settings.", { ...STATIC_ARGS }, async ({ requestModifiers }) => {
+    const org = await getOrg(requestModifiers);
     return {
         content: [
             {
@@ -204,19 +256,117 @@ server.tool("get-org-information", "Get general information about the organizati
         ],
     };
 });
+async function handleCreateVideoWallRequest(videoWallCreateOptions, headers) {
+    let text = "Unable to create video wall!";
+    // console.error("🔨 Creating video wall");
+    if (!videoWallCreateOptions?.displayName) {
+        text = JSON.stringify({
+            needUserInput: true,
+            commandForUser: "What should the name of the video wall be?",
+        });
+    }
+    else if ((videoWallCreateOptions?.deviceList || []).length === 0) {
+        text = JSON.stringify({
+            needUserInput: true,
+            commandForUser: "Which cameras would you like on this video wall?",
+        });
+    }
+    else {
+        // console.error("Creating video wall with options: ", JSON.stringify(videoWallCreateOptions));
+        text = JSON.stringify(await createVideoWall(videoWallCreateOptions, headers));
+    }
+    return Promise.resolve({
+        content: [
+            {
+                type: "text",
+                text,
+            },
+        ],
+    });
+}
+server.tool("create-tool", "Tool for creating many entity types such as video walls.", {
+    entityType: z.enum(["video-wall"]).describe("The entity type to create.  Example: video wall."),
+    videoWallCreateOptions: CreateVideoWallOptions,
+    ...STATIC_ARGS,
+}, async ({ entityType, videoWallCreateOptions, requestModifiers }) => {
+    switch (entityType) {
+        case "video-wall":
+            return await handleCreateVideoWallRequest(videoWallCreateOptions, requestModifiers);
+        default:
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: "",
+            },
+        ],
+    };
+});
+function nullToUndefined(value) {
+    return value === null ? undefined : value;
+}
+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
+        .optional(z.string())
+        .describe("Optional IANA timezone string (e.g., 'America/Los_Angeles', 'UTC'). Defaults to system timezone."),
+}, 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,
+                }),
+            },
+        ],
+    };
+});
 server.tool("get-entity-tool", "get a list of entities like cameras, access controlled doors, sensors, etc", {
     entityType: z
         .enum(["camera", "access-controlled-doors"])
         .describe("The entity type to retreive.  Example: cameras."),
     ...STATIC_ARGS,
-}, async ({ entityType, headers }) => {
+}, async ({ entityType, requestModifiers }) => {
     let ret;
     switch (entityType) {
         case "camera":
-            ret = await getCameraList(headers);
+            ret = await getCameraList(requestModifiers);
             break;
         case "access-controlled-doors":
-            ret = await getAccessControlledDoors(headers);
+            ret = await getAccessControlledDoors(requestModifiers);
             break;
         default:
             ret = {};
@@ -231,12 +381,14 @@ server.tool("get-entity-tool", "get a list of entities like cameras, access cont
         ],
     };
 });
-server.tool("camera-tool", "get specific requested information about a camera such as an image snapshot, or detailed analytics info.  this can be used to answer questions about tracking people across cameras", {
+server.tool("camera-tool", 'This tool captures and returns a real-time snapshot from a designated security camera. The image reflects the current scene in the camera\'s field of view and serves as a contextual input source for downstream tasks such as object recognition, anomaly detection, incident investigation, or situational assessment. When invoked, the tool provides the following: \n •	Visual Scene Capture: A high-resolution image of what the camera is actively observing, including people, vehicles, license plates, and any detectable objects. \n•	Scene Context: Metadata such as camera ID, location name, timestamp, and motion detection status if available. \n•	Enriched Data Potential: The image can be paired with AI models or downstream analytics to extract insights such as: \n•	Number and type of objects in frame (e.g., humans, cars, packages) \n•	Unusual behaviors (e.g., loitering, unauthorized access) \n•	Environmental conditions (e.g., lighting, obstruction, cleanliness) \nUse Cases: \n•	Verify what triggered a motion alert or analytic rule. \n•	Provide visual context for access events or alarms. \n•	Support live incident triage or retrospective investigations. \n•	Feed contextual imagery to agents making security or operational decisions. \nInvocation Notes: \nTo use this tool correctly, the agent should provide the specific camera identifier or location name. If possible, include the intent (e.g., "verify unauthorized access", "identify vehicle", "check for obstructions") to enhance downstream processing or summarization.', {
     requestType: z.enum(["image"]),
-    timestampMs: z.optional(z.number()).describe("the timestamp in milliseconds"),
+    timestampMs: z
+        .optional(z.number())
+        .describe("the timestamp in milliseconds which should always be obtained using time-tool"),
     cameraUuid: z.optional(z.string()).describe("the camera uuid requested"),
     ...STATIC_ARGS,
-}, async ({ cameraUuid, timestampMs, requestType, headers }) => {
+}, async ({ cameraUuid, timestampMs, requestType, requestModifiers }) => {
     if (!cameraUuid) {
         return {
             content: [
@@ -266,7 +418,7 @@ server.tool("camera-tool", "get specific requested information about a camera su
     let response;
     switch (requestType) {
         case "image":
-            response = await getImageForCameraAtTime(cameraUuid, timestampMs, headers);
+            response = await getImageForCameraAtTime(cameraUuid, timestampMs, requestModifiers);
             if (!response.success || !response.imageData) {
                 return {
                     content: [{ type: "text", text: JSON.stringify(response) }],
@@ -303,9 +455,9 @@ server.tool("events-tool", "event data for certain types of information like fac
     locationUuid: z.optional(z.string()),
     accessControlledDoorUuid: z.optional(z.string()),
     ...STATIC_ARGS,
-}, async ({ eventType, locationUuid, accessControlledDoorUuid, headers }) => {
+}, async ({ eventType, locationUuid, accessControlledDoorUuid, requestModifiers }) => {
     if (eventType === "faces" || eventType === "people") {
-        const response = await getFaceEvents(locationUuid, headers);
+        const response = await getFaceEvents(locationUuid, requestModifiers);
         return {
             content: [
                 {
@@ -330,7 +482,7 @@ server.tool("events-tool", "event data for certain types of information like fac
             };
         }
         else {
-            const events = await getAccessControlEvents(accessControlledDoorUuid, headers);
+            const events = await getAccessControlEvents(accessControlledDoorUuid, requestModifiers);
             return {
                 content: [
                     {
@@ -351,14 +503,14 @@ server.tool("events-tool", "event data for certain types of information like fac
     };
 });
 server.tool("location-tool", "contains basic operations for locations and response in JSON format.", {
-    action: z.enum(["get"]),
+    action: z.enum(["get", "update"]),
     locationUpdate: z.optional(z.object({ uuid: z.string(), name: z.optional(z.string()) })),
     ...STATIC_ARGS,
-}, async ({ action, locationUpdate, headers }) => {
+}, async ({ action, locationUpdate, requestModifiers }) => {
     let ret;
     switch (action) {
         case "get":
-            ret = await getLocations(headers);
+            ret = await getLocations(requestModifiers);
             break;
         default:
             ret = { error: true, status: `unsupported location tool call: ${action}` };
@@ -373,8 +525,8 @@ server.tool("reboot-cameras", "this tool is for rebooting one or more cameras ca
         .array(z.string())
         .describe("An array of camera UUID strings which are unique identifiers for cameras"),
     ...STATIC_ARGS,
-}, async ({ cameraUuids, headers }) => {
-    const cameraRebootData = await rebootCameras(cameraUuids, headers);
+}, async ({ cameraUuids, requestModifiers }) => {
+    const cameraRebootData = await rebootCameras(cameraUuids, requestModifiers);
     if (!cameraRebootData) {
         return {
             content: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhombus-node-mcp",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "MCP server for Rhombus API",
   "keywords": [
     "ai",
@@ -33,9 +33,12 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.9.0",
+    "chrono-node": "^2.8.0",
+    "luxon": "^3.6.1",
     "zod": "^3.24.2"
   },
   "devDependencies": {
+    "@types/luxon": "^3.6.2",
     "@types/node": "^22.14.0",
     "prettier": "3.5.3",
     "typescript": "^5.8.3"