rhombus-node-mcp 0.1.7 → 0.1.9

package/dist/index.js

@@ -8,15 +8,18 @@ const RHOMBUS_API_KEY = process.env.RHOMBUS_API_KEY;
 if (!RHOMBUS_API_KEY) {
     console.error("Missing RHOMBUS_API_KEY");
 }
-const BASE_URL = "https://api2.rhombussystems.com/api";
+const enableLogs = process.env.ENABLE_LOGS;
+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",
@@ -27,18 +30,44 @@ 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. 😅"),
 };
-async function postApi(url, body, customHeaders) {
-    let headers = {
-        ...(customHeaders || AUTH_HEADERS),
+const log = (msg) => {
+    if (!enableLogs)
+        return;
+    console.error(msg);
+};
+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 {
-        console.error(`[POSTAPI] - ${url} - ${body} - ${JSON.stringify(customHeaders)}`);
-        const response = await fetch(url, { method: "POST", headers, body });
+        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) {
             if (response.status === 401 || response.status === 403) {
                 return {
@@ -51,33 +80,34 @@ async function postApi(url, body, customHeaders) {
         return await response.json();
     }
     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;
@@ -98,7 +128,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,
@@ -108,13 +138,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(),
@@ -122,14 +152,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++;
             }
@@ -151,7 +181,7 @@ async function rebootCameras(cameraUuids, headers) {
         return { status, successCount, errorCount };
     }
 }
-async function getImageForCameraAtTime(cameraUuid, timestampMs, headers) {
+async function getImageForCameraAtTime(cameraUuid, timestampMs, requestModifiers) {
     const url = BASE_URL + "/video/getExactFrameUri";
     const body = JSON.stringify({
         cameraUuid: cameraUuid,
@@ -163,8 +193,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();
@@ -186,8 +220,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: [
             {
@@ -202,14 +236,14 @@ server.tool("get-entity-tool", "get a list of entities like cameras, access cont
         .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 = {};
@@ -229,7 +263,7 @@ server.tool("camera-tool", "get specific requested information about a camera su
     timestampMs: z.optional(z.number()).describe("the timestamp in milliseconds"),
     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: [
@@ -259,7 +293,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) }],
@@ -296,9 +330,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: [
                 {
@@ -323,7 +357,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: [
                     {
@@ -347,11 +381,11 @@ server.tool("location-tool", "contains basic operations for locations and respon
     action: z.enum(["get"]),
     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}` };
@@ -366,8 +400,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.7",
+  "version": "0.1.9",
   "description": "MCP server for Rhombus API",
   "keywords": [
     "ai",