mcp-cohesity 2.0.0

package/dist/tools/stats.js

@@ -0,0 +1,164 @@
+import { z } from "zod";
+function toolResult(text, isError = false) {
+    return { content: [{ type: "text", text }], isError };
+}
+export function registerStatsTools(server, client) {
+    // ── Cluster Storage Stats ────────────────────────────────────────────
+    server.tool("get_cluster_storage_stats", "Get current cluster storage statistics including total capacity, used space, data reduction ratios, and storage breakdown by category. Useful for capacity planning.", {}, async () => {
+        try {
+            const result = await client.getV2("stats/cluster-storage");
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error fetching cluster storage stats: ${error}`, true);
+        }
+    });
+    // ── Workload Stats ───────────────────────────────────────────────────
+    server.tool("get_workload_stats", "Get high-level workload statistics showing data volumes and counts per workload type (VMware, Physical, NAS, SQL, etc.) on the cluster.", {}, async () => {
+        try {
+            const result = await client.getV2("stats/workload-stats");
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error fetching workload stats: ${error}`, true);
+        }
+    });
+    // ── Replication Backlog Stats ────────────────────────────────────────
+    server.tool("get_replication_backlog", "Get replication backlog statistics showing how much data is pending replication to remote clusters. Useful for monitoring replication health.", {
+        is_inbound: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("If true, returns inbound replication stats. Default is outbound."),
+        target_cluster_ids: z
+            .array(z.number())
+            .optional()
+            .describe("Filter to specific remote cluster IDs"),
+    }, async ({ is_inbound, target_cluster_ids }) => {
+        try {
+            const params = {
+                isInBound: String(is_inbound),
+            };
+            if (target_cluster_ids)
+                params.targetClusterList = target_cluster_ids.join(",");
+            const result = await client.getV2("stats/replication-backlog", params);
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error fetching replication backlog: ${error}`, true);
+        }
+    });
+    // ── Replication Clusters ─────────────────────────────────────────────
+    // The cluster requires startTimeMsecs, rollupIntervalSecs, and
+    // targetClusterList. Defaults: last 30 days, daily rollup, all clusters.
+    server.tool("get_replication_clusters", "Get list of remote replication clusters with total data replicated to/from each. Shows replication partner health at a glance.", {
+        start_time_msecs: z
+            .number()
+            .optional()
+            .describe("Start of stats window in Unix milliseconds (default: 30 days ago)"),
+        rollup_interval_secs: z
+            .number()
+            .optional()
+            .default(86400)
+            .describe("Granularity in seconds (default: 86400 = daily)"),
+        target_cluster_ids: z
+            .array(z.number())
+            .optional()
+            .describe("Restrict to these target cluster IDs (default: all clusters)"),
+        is_inbound: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("If true, returns inbound replication stats. Default is outbound."),
+    }, async ({ start_time_msecs, rollup_interval_secs, target_cluster_ids, is_inbound }) => {
+        try {
+            const startMs = start_time_msecs ?? Date.now() - 30 * 86400 * 1000;
+            const targets = target_cluster_ids?.length
+                ? target_cluster_ids.join(",")
+                : "0"; // 0 = treat as 'all'; cluster accepts and returns all
+            const params = {
+                startTimeMsecs: String(startMs),
+                rollupIntervalSecs: String(rollup_interval_secs),
+                targetClusterList: targets,
+                isInBound: String(is_inbound),
+            };
+            const result = await client.getV2("stats/replication-clusters", params);
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error fetching replication clusters: ${error}`, true);
+        }
+    });
+    // ── Replication Data Trend ───────────────────────────────────────────
+    server.tool("get_replication_data_trend", "Get replication data transfer trends over a time range. Returns time-series data showing how much data was replicated at each interval. Useful for capacity planning and SLA reporting.", {
+        start_time_msecs: z
+            .number()
+            .describe("Start time in Unix milliseconds"),
+        end_time_msecs: z
+            .number()
+            .optional()
+            .describe("End time in Unix milliseconds (defaults to now)"),
+        rollup_interval_secs: z
+            .number()
+            .optional()
+            .default(3600)
+            .describe("Granularity of data points in seconds (e.g. 3600 = hourly, 86400 = daily)"),
+        is_inbound: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("If true, returns inbound replication trends"),
+    }, async ({ start_time_msecs, end_time_msecs, rollup_interval_secs, is_inbound }) => {
+        try {
+            const params = {
+                startTimeMsecs: String(start_time_msecs),
+                rollupIntervalSecs: String(rollup_interval_secs),
+                isInBound: String(is_inbound),
+            };
+            if (end_time_msecs)
+                params.endTimeMsecs = String(end_time_msecs);
+            const result = await client.getV2("stats/replication-data-trend", params);
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error fetching replication data trend: ${error}`, true);
+        }
+    });
+    // ── Replication Objects ──────────────────────────────────────────────
+    server.tool("get_replication_objects", "List all objects that have been replicated to remote clusters in the given time range, with per-object replication status and data size.", {
+        start_time_msecs: z
+            .number()
+            .optional()
+            .describe("Start time in Unix milliseconds"),
+        end_time_msecs: z
+            .number()
+            .optional()
+            .describe("End time in Unix milliseconds"),
+        is_inbound: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("If true, returns inbound replicated objects"),
+        target_cluster_ids: z
+            .array(z.number())
+            .optional()
+            .describe("Filter to specific remote cluster IDs"),
+    }, async ({ start_time_msecs, end_time_msecs, is_inbound, target_cluster_ids }) => {
+        try {
+            const params = {
+                isInBound: String(is_inbound),
+            };
+            if (start_time_msecs)
+                params.startTimeMsecs = String(start_time_msecs);
+            if (end_time_msecs)
+                params.endTimeMsecs = String(end_time_msecs);
+            if (target_cluster_ids)
+                params.targetClusterList = target_cluster_ids.join(",");
+            const result = await client.getV2("stats/replication-objects", params);
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error fetching replication objects: ${error}`, true);
+        }
+    });
+}

package/dist/tools/storage.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CohesityClient } from "../cohesity-client.js";
+export declare function registerStorageTools(server: McpServer, client: CohesityClient): void;

package/dist/tools/storage.js

@@ -0,0 +1,191 @@
+import { z } from "zod";
+function toolResult(text, isError = false) {
+    return { content: [{ type: "text", text }], isError };
+}
+export function registerStorageTools(server, client) {
+    // ── List Storage Domains ─────────────────────────────────────────────
+    server.tool("list_storage_domains", "List Cohesity storage domains (view boxes) where backups are stored. The storage domain ID is required when creating protection groups.", {
+        name: z
+            .string()
+            .optional()
+            .describe("Filter storage domains by name (partial match)"),
+        max_results: z
+            .number()
+            .optional()
+            .default(50)
+            .describe("Maximum number of results to return"),
+    }, async ({ name, max_results }) => {
+        try {
+            const params = {
+                maxCount: String(max_results),
+            };
+            if (name)
+                params.name = name;
+            const result = await client.getV2("storage-domains", params);
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error fetching storage domains: ${error}`, true);
+        }
+    });
+    // ── List Objects ─────────────────────────────────────────────────────
+    server.tool("list_objects", "List protectable objects under a registered source (e.g., all VMs under a vCenter). Returns objects with direct 'id' fields suitable for use in protection groups. Requires a parentId (source or container ID from list_sources).", {
+        parent_id: z
+            .number()
+            .describe("ID of the parent source or container (e.g., vCenter ID, datacenter ID)"),
+        environments: z
+            .array(z.enum([
+            "kVMware", "kHyperV", "kPhysical", "kSQL", "kOracle",
+            "kNetapp", "kGenericNas", "kIsilon", "kFlashBlade",
+            "kKubernetes", "kAWS", "kAzure", "kGCP",
+        ]))
+            .optional()
+            .describe("Filter by environment type"),
+        max_results: z
+            .number()
+            .optional()
+            .default(100)
+            .describe("Maximum number of results to return"),
+    }, async ({ parent_id, environments, max_results }) => {
+        try {
+            await client.refreshAllSources();
+            const params = {
+                parentId: String(parent_id),
+                maxCount: String(max_results),
+            };
+            if (environments)
+                params.environments = environments.join(",");
+            const result = await client.getV2("data-protect/objects", params);
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error listing objects for parent ${parent_id}: ${error}`, true);
+        }
+    });
+    // ── List Snapshots ───────────────────────────────────────────────────
+    server.tool("list_snapshots", "List available backup snapshots for a specific object (VM, database, etc.). Use the object ID from search_objects (objectProtectionInfos[0].objectId) or list_objects. Snapshot IDs are required for recovery operations.", {
+        object_id: z
+            .number()
+            .describe("Object ID to list snapshots for"),
+        protection_group_ids: z
+            .array(z.string())
+            .optional()
+            .describe("Filter snapshots by protection group IDs"),
+        run_types: z
+            .array(z.enum(["kRegular", "kFull", "kLog", "kSystem"]))
+            .optional()
+            .describe("Filter by backup run type"),
+        from_time_usecs: z
+            .number()
+            .optional()
+            .describe("Return snapshots taken after this Unix timestamp in microseconds"),
+        to_time_usecs: z
+            .number()
+            .optional()
+            .describe("Return snapshots taken before this Unix timestamp in microseconds"),
+        max_results: z
+            .number()
+            .optional()
+            .default(25)
+            .describe("Maximum number of snapshots to return"),
+    }, async ({ object_id, protection_group_ids, run_types, from_time_usecs, to_time_usecs, max_results }) => {
+        try {
+            const params = {
+                maxCount: String(max_results),
+            };
+            if (protection_group_ids)
+                params.protectionGroupIds = protection_group_ids.join(",");
+            if (run_types)
+                params.runTypes = run_types.join(",");
+            if (from_time_usecs !== undefined)
+                params.fromTimeUsecs = String(from_time_usecs);
+            if (to_time_usecs !== undefined)
+                params.toTimeUsecs = String(to_time_usecs);
+            const result = await client.getV2(`data-protect/objects/${object_id}/snapshots`, params);
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error listing snapshots for object ${object_id}: ${error}`, true);
+        }
+    });
+    // ── Browse Snapshot Files ────────────────────────────────────────────
+    server.tool("browse_snapshot_files", "Browse files and folders in a VM snapshot using Cohesity's indexed file search. Returns immediate children of the specified path. Requires indexing to be enabled on the protection group. Use object_id from search_objects (objectProtectionInfos[0].objectId). If indexing is not enabled, enable it via update_protection_group first.", {
+        object_id: z
+            .number()
+            .describe("Object (VM) ID to browse — use objectProtectionInfos[0].objectId from search_objects"),
+        path: z
+            .string()
+            .optional()
+            .default("/")
+            .describe("Directory path to browse (e.g. '/home/zerto', '/etc'). Defaults to root."),
+        search_string: z
+            .string()
+            .optional()
+            .describe("Filename pattern to search (e.g. '*.log', 'config*'). Defaults to the last segment of the path, which finds files in that directory."),
+        max_results: z
+            .number()
+            .optional()
+            .default(200)
+            .describe("Maximum number of indexed entries to fetch"),
+    }, async ({ object_id, path, search_string, max_results }) => {
+        try {
+            // Normalize path: strip trailing slash, ensure leading slash
+            const normPath = ("/" + path.replace(/^\/+|\/+$/g, "")).replace(/\/+/g, "/");
+            // Derive a useful search string from the path when not provided.
+            // Using "*" alone alphabetically exhausts count before reaching deeper paths like /home.
+            // Using the last path segment (e.g. "zerto" for /home/zerto) finds files in that directory.
+            const segments = normPath.split("/").filter(Boolean);
+            const effectiveSearch = search_string ?? (segments.length > 0 ? segments[segments.length - 1] : "*");
+            const body = {
+                objectType: "Files",
+                fileParams: {
+                    searchString: effectiveSearch,
+                    sourceEnvironments: ["kVMware"],
+                },
+                objectIds: [object_id],
+                count: max_results,
+            };
+            const result = await client.postV2("data-protect/search/indexed-objects", body);
+            const files = result.files ?? [];
+            if (files.length === 0) {
+                return toolResult(`No indexed files found for object ${object_id}. Indexing may not be enabled on this VM's protection group. ` +
+                    `Enable it with update_protection_group using vmwareParams.indexingPolicy.enableIndexing=true, then wait for the next backup run.`);
+            }
+            // Each entry has { name, path } where path is the parent directory with lvol_N/ prefix.
+            // Full path = path + "/" + name, then strip lvol_N/ prefix.
+            const toClean = (p) => ("/" + p.replace(/^lvol_\d+\/?/, "")).replace(/\/+/g, "/");
+            // Build full clean paths for all entries
+            const allEntries = files.map(f => {
+                const rawFull = f.path + "/" + f.name;
+                const cleanFull = toClean(rawFull);
+                const cleanParent = toClean(f.path);
+                return { name: f.name, cleanFull, cleanParent, type: f.type };
+            });
+            // Filter to entries whose parent equals the requested path (direct children)
+            const isRoot = normPath === "/";
+            const children = allEntries.filter(e => {
+                if (isRoot) {
+                    // Direct children of root: parent is "/" or ""
+                    return e.cleanParent === "/" || e.cleanParent === "";
+                }
+                return e.cleanParent === normPath;
+            });
+            if (children.length === 0) {
+                // No direct children found — show all unique top-level paths as hint
+                const uniquePaths = [...new Set(allEntries.map(e => e.cleanParent))].sort().slice(0, 20);
+                return toolResult(`No entries found directly under '${normPath}'. ` +
+                    `Indexed paths available: ${uniquePaths.join(", ")}. ` +
+                    `Try browsing one of these paths, or use a broader search_string.`);
+            }
+            const entries = children.map(e => ({
+                name: e.name,
+                path: e.cleanFull,
+                type: e.type.toLowerCase().replace("k", ""),
+            }));
+            return toolResult(JSON.stringify({ browsed_path: normPath, object_id, count: entries.length, entries }, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error browsing snapshot files for object ${object_id}: ${error}`, true);
+        }
+    });
+}

package/dist/tools/tiering.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CohesityClient } from "../cohesity-client.js";
+export declare function registerTieringTools(server: McpServer, client: CohesityClient): void;

package/dist/tools/tiering.js

@@ -0,0 +1,132 @@
+import { z } from "zod";
+function toolResult(text, isError = false) {
+    return { content: [{ type: "text", text }], isError };
+}
+export function registerTieringTools(server, client) {
+    // ── List Data Tiering Tasks ──────────────────────────────────────────
+    server.tool("list_tiering_tasks", "List all data tiering tasks that move cold data from primary storage to external targets (cloud, vault). Shows status, schedule, and source/target configuration.", {
+        ids: z
+            .array(z.string())
+            .optional()
+            .describe("Filter by specific task IDs"),
+        include_downtiered_locations: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include list of locations where data has been down-tiered"),
+    }, async ({ ids, include_downtiered_locations }) => {
+        try {
+            const params = {
+                includeDowntieredDataLocation: String(include_downtiered_locations),
+            };
+            if (ids)
+                params.ids = ids.join(",");
+            const result = await client.getV2("data-tiering/tasks", params);
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error listing tiering tasks: ${error}`, true);
+        }
+    });
+    // ── Get Tiering Task ─────────────────────────────────────────────────
+    server.tool("get_tiering_task", "Get details of a specific data tiering task by ID.", {
+        id: z.string().describe("Tiering task ID"),
+    }, async ({ id }) => {
+        try {
+            const result = await client.getV2(`data-tiering/tasks/${id}`);
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error fetching tiering task ${id}: ${error}`, true);
+        }
+    });
+    // ── Create Tiering Task ──────────────────────────────────────────────
+    server.tool("create_tiering_task", "Create a data tiering task to automatically move cold data from a NAS/View source to an external target. Requires a registered external target (use list_external_targets to find IDs).", {
+        name: z.string().describe("Name for the tiering task"),
+        description: z.string().optional().describe("Optional description"),
+        source_id: z
+            .number()
+            .describe("Source protection source ID (NAS or View source from list_sources)"),
+        external_target_id: z
+            .number()
+            .describe("Destination external target ID (from list_external_targets)"),
+        days_cold: z
+            .number()
+            .optional()
+            .default(90)
+            .describe("Tier data that has not been accessed for this many days"),
+        schedule_unit: z
+            .enum(["Days", "Weeks"])
+            .optional()
+            .default("Days")
+            .describe("Tiering schedule frequency unit"),
+        schedule_frequency: z
+            .number()
+            .optional()
+            .default(1)
+            .describe("How often to run the tiering task (e.g. 1 = daily)"),
+    }, async ({ name, description, source_id, external_target_id, days_cold, schedule_unit, schedule_frequency }) => {
+        try {
+            const body = {
+                name,
+                type: "Downtier",
+                source: { id: source_id },
+                targets: [{ id: external_target_id }],
+                filtersConfig: {
+                    lastAccessTimeFilter: {
+                        daysCount: days_cold,
+                    },
+                },
+                schedule: {
+                    unit: schedule_unit,
+                    frequency: schedule_frequency,
+                },
+            };
+            if (description)
+                body.description = description;
+            const result = await client.postV2("data-tiering/tasks", body);
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error creating tiering task: ${error}`, true);
+        }
+    });
+    // ── Run Tiering Task ─────────────────────────────────────────────────
+    server.tool("run_tiering_task", "Trigger an on-demand run of a data tiering task.", {
+        id: z.string().describe("Tiering task ID to run"),
+    }, async ({ id }) => {
+        try {
+            await client.postV2(`data-tiering/tasks/${id}/runs`, {});
+            return toolResult(`Tiering task ${id} run initiated successfully.`);
+        }
+        catch (error) {
+            return toolResult(`Error running tiering task ${id}: ${error}`, true);
+        }
+    });
+    // ── Pause / Resume Tiering Task ──────────────────────────────────────
+    server.tool("update_tiering_task_state", "Pause or resume one or more data tiering tasks.", {
+        ids: z.array(z.string()).describe("List of tiering task IDs"),
+        action: z.enum(["Pause", "Resume"]).describe("Action to perform"),
+    }, async ({ ids, action }) => {
+        try {
+            const body = { ids, action };
+            const result = await client.postV2("data-tiering/tasks/states", body);
+            return toolResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toolResult(`Error updating tiering task state: ${error}`, true);
+        }
+    });
+    // ── Delete Tiering Task ──────────────────────────────────────────────
+    server.tool("delete_tiering_task", "Delete a data tiering task.", {
+        id: z.string().describe("Tiering task ID to delete"),
+    }, async ({ id }) => {
+        try {
+            await client.deleteV2(`data-tiering/tasks/${id}`);
+            return toolResult(`Tiering task ${id} deleted successfully.`);
+        }
+        catch (error) {
+            return toolResult(`Error deleting tiering task ${id}: ${error}`, true);
+        }
+    });
+}

package/dist/tools/users.d.ts

@@ -0,0 +1,13 @@
+/**
+ * User management tools — list, create, update, and delete Cohesity users
+ * (both LOCAL and AD/IdP-backed). All shapes verified against cluster_v2_api.yaml.
+ *
+ *   GET    /v2/users                — UsersList
+ *   POST   /v2/users                — CreateUsersParameters (array of CreateUserParameters)
+ *   POST   /v2/users/delete         — DeleteUsersRequest { sids[] }
+ *   GET    /v2/users/{sid}          — User
+ *   PUT    /v2/users/{sid}          — UpdateUserParameters
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CohesityClient } from "../cohesity-client.js";
+export declare function registerUserTools(server: McpServer, client: CohesityClient): void;