rhombus-node-mcp 0.1.21 → 0.1.23

package/README.md

@@ -24,6 +24,14 @@ Your insights will directly influence our development roadmap and help us create
 
 ## 🔧 Quick Setup
 
+### Installing via Smithery
+
+To install Rhombus MCP Server for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@RhombusSystems/rhombus-node-mcp):
+
+```bash
+npx -y @smithery/cli install @RhombusSystems/rhombus-node-mcp --client claude
+```
+
 ### Step 1: Give Your Rhombus Console Superpowers
 
 1. Login to your Rhombus Console  - [Login Here](https://console.rhombus.com)! 🔐

package/dist/api/access-control-tool-api.js

@@ -0,0 +1,256 @@
+import { postApi } from "../network.js";
+const PERMISSION_RANK = {
+    LIVEONLY: 0,
+    READONLY: 1,
+    ADMIN: 2,
+};
+function hasAtLeastReadonly(perm) {
+    return PERMISSION_RANK[perm ?? ""] >= PERMISSION_RANK.READONLY;
+}
+export async function unlockDoor(doorUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/unlockAccessControlledDoor",
+        body: { accessControlledDoorUuid: doorUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return { success: true, doorUuid };
+}
+export async function getAccessControlGroups(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/findAccessControlGroupsByOrg",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.groups?.map((group) => ({
+        uuid: group.uuid ?? undefined,
+        name: group.name ?? undefined,
+        description: group.description ?? undefined,
+        orgUuid: group.orgUuid ?? undefined,
+        userUuids: group.userUuids?.filter((u) => u !== null) ?? [],
+    })) ?? []);
+}
+export async function getCredentialsByUser(userUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/findAccessControlCredentialByUser",
+        body: { userUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.credentials?.map((cred) => ({
+        uuid: cred.uuid ?? undefined,
+        userUuid: cred.userUuid ?? undefined,
+        credentialType: cred.credentialType ?? undefined,
+        status: cred.workflowStatus ?? undefined,
+        note: cred.note ?? undefined,
+    })) ?? []);
+}
+export async function getLockdownPlans(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/lockdownPlan/findLockdownPlans",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.lockdownPlans?.map((plan) => ({
+        uuid: plan.uuid ?? undefined,
+        name: plan.name ?? undefined,
+        locationUuid: plan.locationUuid ?? undefined,
+        description: plan.description ?? undefined,
+        active: plan.active ?? undefined,
+    })) ?? []);
+}
+export async function activateLockdown(locationUuid, lockdownPlanUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/lockdownPlan/activateLockdownForLocation",
+        body: { locationUuid, lockdownPlanUuids: [lockdownPlanUuid] },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return { success: true, locationUuid, action: "activated" };
+}
+export async function deactivateLockdown(locationUuid, lockdownPlanUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/lockdownPlan/deactivateLockdownForLocation",
+        body: { locationUuid, lockdownPlanUuids: [lockdownPlanUuid] },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return { success: true, locationUuid, action: "deactivated" };
+}
+export async function getDoorScheduleExceptions(locationUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/doorScheduleException/findExceptionsV2",
+        body: { locationUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    return (res.exceptions?.map((exc) => ({
+        uuid: exc.uuid ?? undefined,
+        name: exc.name ?? undefined,
+        startTime: exc.startTimeMs ?? undefined,
+        endTime: exc.endTimeMs ?? undefined,
+        doorUuids: exc.doorUuids?.filter((d) => d !== null) ?? [],
+    })) ?? []);
+}
+export async function getAccessGrants(locationUuid, requestModifiers, sessionId) {
+    const res = locationUuid
+        ? await postApi({
+            route: "/accesscontrol/findLocationAccessGrantsByLocation",
+            body: { locationUuid },
+            modifiers: requestModifiers,
+            sessionId,
+        })
+        : await postApi({
+            route: "/accesscontrol/findLocationAccessGrantsByOrg",
+            body: {},
+            modifiers: requestModifiers,
+            sessionId,
+        });
+    if (res.error) {
+        throw new Error(JSON.stringify(res));
+    }
+    const filterNulls = (arr) => arr?.filter((v) => v !== null) ?? [];
+    return (res.accessGrants?.map((grant) => ({
+        uuid: grant.uuid ?? undefined,
+        name: grant.name ?? undefined,
+        locationUuid: grant.locationUuid ?? undefined,
+        userUuids: filterNulls(grant.userUuids),
+        groupUuids: filterNulls(grant.groupUuids),
+        doorUuids: filterNulls(grant.accessControlledDoorUuids),
+        scheduleUuid: grant.scheduleUuid ?? undefined,
+    })) ?? []);
+}
+function canRoleUnlockDoor(role, doorLocationUuid, doorAssociatedCameras) {
+    if (role.superAdmin)
+        return true;
+    const hasDoorAdmin = role.functionalityList?.includes("DOOR_ACCESS_ADMINISTRATION");
+    if (!hasDoorAdmin)
+        return false;
+    const acMap = role.accessControlLocationAccessMap ?? {};
+    const granularMap = role.locationGranularAccessMap ?? {};
+    const acLocationPerm = acMap[doorLocationUuid];
+    const granularLocationPerms = granularMap[doorLocationUuid] ?? {};
+    const accessConditionsPerm = granularLocationPerms["ACCESS_CONDITIONS"];
+    if (hasAtLeastReadonly(acLocationPerm) && hasAtLeastReadonly(accessConditionsPerm)) {
+        return true;
+    }
+    if (doorAssociatedCameras.length > 0) {
+        const locationMap = role.locationAccessMap ?? {};
+        const deviceMap = role.deviceAccessMap ?? {};
+        if (hasAtLeastReadonly(locationMap[doorLocationUuid]))
+            return true;
+        for (const cameraUuid of doorAssociatedCameras) {
+            if (hasAtLeastReadonly(deviceMap[cameraUuid]))
+                return true;
+        }
+    }
+    return false;
+}
+export async function getRemoteUnlockUsers(locationUuid, requestModifiers, sessionId) {
+    const [permGroupsRes, doorsRes, usersRes] = await Promise.all([
+        postApi({
+            route: "/permission/getPermissionGroups",
+            body: {},
+            modifiers: requestModifiers,
+            sessionId,
+        }),
+        postApi({
+            route: "/component/findAccessControlledDoors",
+            body: {},
+            modifiers: requestModifiers,
+            sessionId,
+        }),
+        postApi({
+            route: "/user/getUsersInOrg",
+            body: {},
+            modifiers: requestModifiers,
+            sessionId,
+        }),
+    ]);
+    if (permGroupsRes.error)
+        throw new Error(JSON.stringify(permGroupsRes));
+    if (doorsRes.error)
+        throw new Error(JSON.stringify(doorsRes));
+    if (usersRes.error)
+        throw new Error(JSON.stringify(usersRes));
+    const permissionGroups = permGroupsRes.permissionGroups ?? [];
+    const groupMembership = {};
+    for (const [groupUuid, userUuids] of Object.entries(permGroupsRes.groupMembership ?? {})) {
+        groupMembership[groupUuid] = (userUuids ?? []).filter((u) => u !== null);
+    }
+    const userMap = new Map();
+    for (const user of usersRes.users ?? []) {
+        if (user.uuid) {
+            userMap.set(user.uuid, {
+                uuid: user.uuid,
+                firstName: user.firstName ?? undefined,
+                lastName: user.lastName ?? undefined,
+                email: user.email ?? undefined,
+            });
+        }
+    }
+    const doors = (doorsRes.accessControlledDoors ?? []).filter((door) => door.locationUuid === locationUuid && door.remoteUnlockEnabled === true);
+    const doorNames = doors.map((d) => d.name ?? "Unknown");
+    const totalDoors = doorNames.length;
+    const groupResults = new Map();
+    const seenUsers = new Set();
+    for (const door of doors) {
+        const doorLocationUuid = door.locationUuid ?? "";
+        const doorName = door.name ?? "Unknown";
+        const associatedCameras = door.associatedCameras?.filter((c) => c !== null) ?? [];
+        for (const role of permissionGroups) {
+            if (!role.uuid)
+                continue;
+            if (!canRoleUnlockDoor(role, doorLocationUuid, associatedCameras))
+                continue;
+            const roleName = role.name ?? "Unknown";
+            let group = groupResults.get(roleName);
+            if (!group) {
+                group = { doorNames: new Set(), userEntries: new Set() };
+                groupResults.set(roleName, group);
+            }
+            group.doorNames.add(doorName);
+            for (const userUuid of groupMembership[role.uuid] ?? []) {
+                if (!userMap.has(userUuid) || seenUsers.has(userUuid))
+                    continue;
+                seenUsers.add(userUuid);
+                const user = userMap.get(userUuid);
+                const name = [user.firstName, user.lastName].filter(Boolean).join(" ");
+                const label = name
+                    ? `${name} (${user.email ?? "no email"})`
+                    : (user.email ?? userUuid);
+                group.userEntries.add(label);
+            }
+        }
+    }
+    const groups = Array.from(groupResults.entries()).map(([name, g]) => ({
+        permissionGroup: name,
+        doors: g.doorNames.size === totalDoors ? "all" : Array.from(g.doorNames),
+        users: Array.from(g.userEntries),
+    }));
+    const totalUsers = seenUsers.size;
+    return { doors: doorNames, totalUsers, groups };
+}

package/dist/api/alarm-monitoring-tool-api.js

@@ -0,0 +1,65 @@
+import { postApi } from "../network.js";
+export async function getOrgAlarmStatus(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/alertmonitoring/orgStatus",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(res.errorMsg ?? "Failed to get org alarm status");
+    }
+    const statuses = res.locationStatuses ?? {};
+    return Object.entries(statuses).map(([locationUuid, status]) => ({
+        locationUuid,
+        enabled: status?.enabled ?? undefined,
+        enabledOnMs: status?.enabledOnMs ?? undefined,
+        disabledOnMs: status?.disabledOnMs ?? undefined,
+        notEnabledReason: status?.notEnabledReason ?? undefined,
+    }));
+}
+export async function getAlertMonitoringThreatCases(startTimeMs, endTimeMs, maxResults, requestModifiers, sessionId) {
+    const body = {};
+    if (startTimeMs)
+        body.afterTimestampMs = startTimeMs;
+    if (endTimeMs)
+        body.beforeTimestampMs = endTimeMs;
+    if (maxResults)
+        body.maxResults = maxResults;
+    const res = await postApi({
+        route: "/event/getAlertMonitoringThreatCases",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(res.errorMsg ?? "Failed to get threat cases");
+    }
+    return (res.threatCases?.map(tc => ({
+        uuid: tc.uuid ?? undefined,
+        status: tc.status ?? undefined,
+        locationName: tc.locationName ?? undefined,
+        locationUuid: tc.locationUuid ?? undefined,
+        deviceUuid: tc.deviceUuid ?? undefined,
+        createdAtMillis: tc.createdAtMillis ?? undefined,
+        promptTitle: tc.promptTitle ?? undefined,
+    })) ?? []);
+}
+export async function getLocationAlarmStatus(locationUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/alertmonitoring/locationStatus",
+        body: { locationUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(res.errorMsg ?? "Failed to get location alarm status");
+    }
+    return {
+        locationUuid,
+        enabled: res.status?.enabled ?? undefined,
+        enabledOnMs: res.status?.enabledOnMs ?? undefined,
+        disabledOnMs: res.status?.disabledOnMs ?? undefined,
+        notEnabledReason: res.status?.notEnabledReason ?? undefined,
+    };
+}

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

@@ -1,5 +1,5 @@
 import { getLogger } from "../logger.js";
-import { appendQueryParams, AUTH_HEADERS, postApi, STATIC_HEADERS } from "../network.js";
+import { constructRequestHeaders, postApi } from "../network.js";
 import { removeNullFields } from "../util.js";
 const logger = getLogger("camera-tool");
 const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
@@ -8,13 +8,10 @@ export async function getImageForCameraAtTime(cameraUuid, timestampMs, requestMo
         cameraUuid: cameraUuid,
         downscaleFactor: 10,
         jpgQuality: 70,
-        permyriadCropHeight: 10000,
-        permyriadCropWidth: 5625,
-        permyriadCropX: 2188,
-        permyriadCropY: 0,
         timestampMs: timestampMs,
     };
     logger.debug(`Getting frameUri from UUID: ${cameraUuid} at timestampMs: ${timestampMs}`);
+    let frameUri;
     const base64Image = await postApi({
         route: "/video/getExactFrameUri",
         body,
@@ -22,17 +19,17 @@ export async function getImageForCameraAtTime(cameraUuid, timestampMs, requestMo
         sessionId,
     }).then(async (res) => {
         logger.debug(`Received frameUri ${res.frameUri}`);
-        // construct request headers
-        let requestHeaders = {
-            ...(requestModifiers?.headers ?? AUTH_HEADERS),
-            ...STATIC_HEADERS,
-        };
-        // add query params
-        if (requestModifiers?.query) {
-            res.frameUri = appendQueryParams(res.frameUri, requestModifiers.query);
+        if (!res.frameUri) {
+            throw new Error("No frameUri given. Maybe camera does not support it.");
         }
-        logger.trace(`Fetching with headers\n${JSON.stringify(requestHeaders)}`);
-        return await fetch(res.frameUri, {
+        // construct request headers
+        const { url: _frameUri, requestHeaders } = constructRequestHeaders(res.frameUri, requestModifiers, sessionId);
+        frameUri = _frameUri;
+        // remove content type
+        delete requestHeaders["Content-Type"];
+        delete requestHeaders["accept"];
+        logger.debug(`Fetching with headers\n${JSON.stringify(requestHeaders, null, 2)}`);
+        return await fetch(frameUri, {
             method: "GET",
             headers: requestHeaders,
         }).then(async (res) => {
@@ -57,6 +54,7 @@ export async function getImageForCameraAtTime(cameraUuid, timestampMs, requestMo
     return {
         success: true,
         status: "successfully fetched image",
+        frameUri: frameUri ?? "",
         imageType: "base64",
         imageData: base64Image,
     };
@@ -134,6 +132,28 @@ export async function getCameraSettings(cameraUuid, requestModifiers, sessionId)
         status: "fetched camera settings",
     };
 }
+export async function getCameraMediaUris(cameraUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/camera/getCameraMediaUris",
+        body: { deviceUuid: cameraUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return res;
+}
+export async function getCameraAIThresholds(cameraUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/camera/getCameraAIThresholds",
+        body: { deviceUuid: cameraUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return res;
+}
 export async function updateCameraSettings(cameraUuid, update, requestModifiers, sessionId) {
     // remove any "null" values
     const res = await postApi({

package/dist/api/camera-uptime-tool-api.js

@@ -0,0 +1,112 @@
+import { postApi } from "../network.js";
+function computeUptimeStats(cameraUuid, cameraName, locationUuid, windows, startTimeSec, endTimeSec) {
+    const totalPeriodSeconds = endTimeSec - startTimeSec;
+    let totalUptimeSeconds = 0;
+    const sortedWindows = windows
+        .filter(w => w.startSeconds != null && w.durationSeconds != null)
+        .sort((a, b) => (a.startSeconds ?? 0) - (b.startSeconds ?? 0));
+    for (const w of sortedWindows) {
+        const wStart = Math.max(w.startSeconds, startTimeSec);
+        const wEnd = Math.min(w.startSeconds + w.durationSeconds, endTimeSec);
+        if (wEnd > wStart) {
+            totalUptimeSeconds += wEnd - wStart;
+        }
+    }
+    let outageCount = 0;
+    let longestOutageSeconds = 0;
+    let lastEnd = startTimeSec;
+    for (const w of sortedWindows) {
+        const wStart = Math.max(w.startSeconds, startTimeSec);
+        if (wStart > lastEnd) {
+            outageCount++;
+            longestOutageSeconds = Math.max(longestOutageSeconds, wStart - lastEnd);
+        }
+        const wEnd = Math.min(w.startSeconds + w.durationSeconds, endTimeSec);
+        lastEnd = Math.max(lastEnd, wEnd);
+    }
+    if (lastEnd < endTimeSec) {
+        outageCount++;
+        longestOutageSeconds = Math.max(longestOutageSeconds, endTimeSec - lastEnd);
+    }
+    const uptimePercentage = totalPeriodSeconds > 0
+        ? Math.round((totalUptimeSeconds / totalPeriodSeconds) * 10000) / 100
+        : 0;
+    return {
+        cameraUuid,
+        cameraName,
+        locationUuid,
+        totalUptimeSeconds,
+        totalPeriodSeconds,
+        uptimePercentage,
+        outageCount,
+        longestOutageSeconds,
+    };
+}
+export async function getCameraUptime(cameraUuid, startTimeSec, endTimeSec, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/camera/getUptimeWindows",
+        body: {
+            cameraUuid,
+            startTime: startTimeSec,
+            endTime: endTimeSec,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(res.errorMsg ?? "Failed to get camera uptime windows");
+    }
+    return computeUptimeStats(cameraUuid, undefined, undefined, (res.uptimeWindows ?? []), startTimeSec, endTimeSec);
+}
+export async function getFleetUptime(startTimeSec, endTimeSec, requestModifiers, sessionId) {
+    const cameraListRes = await postApi({
+        route: "/camera/getMinimalCameraStateList",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    const cameras = (cameraListRes.cameraStates ?? [])
+        .filter((c) => c.locationUuid)
+        .map((c) => ({
+        uuid: c.uuid,
+        name: c.name ?? c.uuid,
+        locationUuid: c.locationUuid,
+    }));
+    const uptimeResults = [];
+    const batchSize = 10;
+    for (let i = 0; i < cameras.length; i += batchSize) {
+        const batch = cameras.slice(i, i + batchSize);
+        const batchResults = await Promise.all(batch.map(async (cam) => {
+            try {
+                const res = await postApi({
+                    route: "/camera/getUptimeWindows",
+                    body: {
+                        cameraUuid: cam.uuid,
+                        startTime: startTimeSec,
+                        endTime: endTimeSec,
+                    },
+                    modifiers: requestModifiers,
+                    sessionId,
+                });
+                return computeUptimeStats(cam.uuid, cam.name, cam.locationUuid, (res.uptimeWindows ?? []), startTimeSec, endTimeSec);
+            }
+            catch {
+                return computeUptimeStats(cam.uuid, cam.name, cam.locationUuid, [], startTimeSec, endTimeSec);
+            }
+        }));
+        uptimeResults.push(...batchResults);
+    }
+    uptimeResults.sort((a, b) => a.uptimePercentage - b.uptimePercentage);
+    const avgUptime = uptimeResults.length > 0
+        ? Math.round((uptimeResults.reduce((sum, r) => sum + r.uptimePercentage, 0) / uptimeResults.length) * 100) / 100
+        : 0;
+    return {
+        cameras: uptimeResults,
+        summary: {
+            totalCameras: uptimeResults.length,
+            averageUptimePercentage: avgUptime,
+            worstCamera: uptimeResults[0]?.cameraName,
+            worstUptimePercentage: uptimeResults[0]?.uptimePercentage,
+        },
+    };
+}

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

@@ -1,36 +1,125 @@
 import { postApi } from "../network.js";
 export async function getSavedClips(args, requestModifiers, sessionId) {
-    return await postApi({
+    const res = await postApi({
         route: "/event/getClipsWithProgress",
         body: args,
         modifiers: requestModifiers,
         sessionId,
-    }).then(response => {
-        if (response.error)
-            return response;
-        else
-            return (response.savedClips?.map((clip) => ({
-                ...clip,
-                createdAtTimestamp: clip.createdAtMs ? new Date(clip.createdAtMs).toISOString() : null,
-            })) ?? []);
     });
+    if (res.error)
+        return { error: res.errorMsg ?? undefined };
+    return {
+        savedClips: res.savedClips?.map((clip) => ({
+            ...clip,
+            createdAtTimestamp: clip.createdAtMs
+                ? new Date(clip.createdAtMs).toISOString()
+                : null,
+        })) ?? [],
+    };
 }
 export async function getExpiringClips(args, requestModifiers, sessionId) {
-    return await postApi({
+    const res = await postApi({
         route: "/event/getExpiringClipsForOrg",
         body: args,
         modifiers: requestModifiers,
         sessionId,
-    }).then(response => {
-        if (response.error)
-            return response;
-        else
-            return {
-                ...response,
-                savedClips: (response.savedClips || []).map((clip) => ({
-                    ...clip,
-                    createdAtTimestamp: clip.createdAtMs ? new Date(clip.createdAtMs).toISOString() : null,
-                })),
-            };
     });
+    if (res.error)
+        return { error: res.errorMsg ?? undefined };
+    return {
+        expiringClips: res.savedClips?.map((clip) => ({
+            ...clip,
+            createdAtTimestamp: clip.createdAtMs
+                ? new Date(clip.createdAtMs).toISOString()
+                : null,
+        })) ?? [],
+    };
+}
+export async function getSharedLiveStreams(_args, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/camera/findAllSharedLiveVideoStreams",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        return { error: res.errorMsg ?? undefined };
+    return {
+        sharedLiveVideoStreams: res.sharedLiveVideoStreams ?? [],
+    };
+}
+export async function getTimelapseClips(_args, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/video/getTimelapseClips",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        return { error: res.errorMsg ?? undefined };
+    return {
+        timelapseClips: res.timelapseClips ?? [],
+    };
+}
+export async function getClipGroups(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/event/getClipGroupsForOrg",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return {
+        clipGroups: (res.clipGroups || []).map((group) => ({
+            uuid: group.uuid ?? undefined,
+            name: group.name ?? undefined,
+            clipCount: group.clipCount ?? undefined,
+        })),
+    };
+}
+export async function getSharedClipGroups(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/event/getSharedClipGroupsV2",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return {
+        sharedClipGroups: (res.sharedClipGroups || []).map((group) => ({
+            uuid: group.uuid ?? undefined,
+            name: group.title ?? undefined,
+        })),
+    };
+}
+export async function createClip(cameraUuid, startTimeMs, endTimeMs, requestModifiers, sessionId) {
+    const durationSec = Math.round((endTimeMs - startTimeMs) / 1000);
+    const body = {
+        deviceUuids: [cameraUuid],
+        startTimeMillis: startTimeMs,
+        durationSec,
+        saveToConsole: true,
+    };
+    const res = await postApi({
+        route: "/video/spliceV3",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return { spliceResult: { success: true, clipUuid: res.clipUuid ?? undefined } };
+}
+export async function deleteClip(clipUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/event/deleteSavedClip",
+        body: { savedClipUuid: clipUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return { deleteResult: { success: true } };
 }