@gcnv/gcnv-mcp-server 1.0.3

package/build/registry/register-tools.js

@@ -0,0 +1,101 @@
+import { createStoragePoolTool, deleteStoragePoolTool, getStoragePoolTool, listStoragePoolsTool, updateStoragePoolTool, validateDirectoryServiceTool, } from '../tools/storage-pool-tools.js';
+import { createStoragePoolHandler, deleteStoragePoolHandler, getStoragePoolHandler, listStoragePoolsHandler, updateStoragePoolHandler, validateDirectoryServiceHandler, } from '../tools/handlers/storage-pool-handler.js';
+import { createVolumeTool, deleteVolumeTool, getVolumeTool, listVolumesTool, updateVolumeTool, } from '../tools/volume-tools.js';
+import { createVolumeHandler, deleteVolumeHandler, getVolumeHandler, listVolumesHandler, updateVolumeHandler, } from '../tools/handlers/volume-handler.js';
+import { createSnapshotTool, deleteSnapshotTool, getSnapshotTool, listSnapshotsTool, revertVolumeToSnapshotTool, updateSnapshotTool, } from '../tools/snapshot-tools.js';
+import { createSnapshotHandler, deleteSnapshotHandler, getSnapshotHandler, listSnapshotsHandler, revertVolumeToSnapshotHandler, updateSnapshotHandler, } from '../tools/handlers/snapshot-handler.js';
+import { createBackupVaultTool, deleteBackupVaultTool, getBackupVaultTool, listBackupVaultsTool, updateBackupVaultTool, } from '../tools/backup-vault-tools.js';
+import { createBackupVaultHandler, deleteBackupVaultHandler, getBackupVaultHandler, listBackupVaultsHandler, updateBackupVaultHandler, } from '../tools/handlers/backup-vault-handler.js';
+import { createBackupTool, deleteBackupTool, getBackupTool, listBackupsTool, restoreBackupTool, updateBackupTool, } from '../tools/backup-tools.js';
+import { createBackupHandler, deleteBackupHandler, getBackupHandler, listBackupsHandler, restoreBackupHandler, updateBackupHandler, } from '../tools/handlers/backup-handler.js';
+import { getOperationTool, cancelOperationTool, listOperationsTool, } from '../tools/operation-tools.js';
+import { getOperationHandler, cancelOperationHandler, listOperationsHandler, } from '../tools/handlers/operation-handler.js';
+import { createBackupPolicyTool, deleteBackupPolicyTool, getBackupPolicyTool, listBackupPoliciesTool, updateBackupPolicyTool, } from '../tools/backup-policy-tools.js';
+import { backupPolicyHandlers } from '../tools/handlers/backup-policy-handler.js';
+import { createReplicationTool, deleteReplicationTool, getReplicationTool, listReplicationsTool, updateReplicationTool, resumeReplicationTool, stopReplicationTool, reverseReplicationDirectionTool, establishPeeringTool, syncReplicationTool, } from '../tools/replication-tools.js';
+import { createReplicationHandler, deleteReplicationHandler, getReplicationHandler, listReplicationsHandler, updateReplicationHandler, resumeReplicationHandler, stopReplicationHandler, reverseReplicationDirectionHandler, establishPeeringHandler, syncReplicationHandler, } from '../tools/handlers/replication-handler.js';
+import { createActiveDirectoryTool, deleteActiveDirectoryTool, getActiveDirectoryTool, listActiveDirectoriesTool, updateActiveDirectoryTool, } from '../tools/active-directory-tools.js';
+import { createActiveDirectoryHandler, deleteActiveDirectoryHandler, getActiveDirectoryHandler, listActiveDirectoriesHandler, updateActiveDirectoryHandler, } from '../tools/handlers/active-directory-handler.js';
+import { createKmsConfigTool, deleteKmsConfigTool, getKmsConfigTool, listKmsConfigsTool, updateKmsConfigTool, verifyKmsConfigTool, encryptVolumesTool, } from '../tools/kms-config-tools.js';
+import { createKmsConfigHandler, deleteKmsConfigHandler, getKmsConfigHandler, listKmsConfigsHandler, updateKmsConfigHandler, verifyKmsConfigHandler, encryptVolumesHandler, } from '../tools/handlers/kms-config-handler.js';
+import { createQuotaRuleTool, deleteQuotaRuleTool, getQuotaRuleTool, listQuotaRulesTool, updateQuotaRuleTool, } from '../tools/quota-rule-tools.js';
+import { createQuotaRuleHandler, deleteQuotaRuleHandler, getQuotaRuleHandler, listQuotaRulesHandler, updateQuotaRuleHandler, } from '../tools/handlers/quota-rule-handler.js';
+/**
+ * Register all tools and their handlers to the tool registry
+ */
+export function registerAllTools(mcpServer) {
+    // Register storage pool tools
+    mcpServer.registerTool(createStoragePoolTool.name, createStoragePoolTool, createStoragePoolHandler);
+    mcpServer.registerTool(deleteStoragePoolTool.name, deleteStoragePoolTool, deleteStoragePoolHandler);
+    mcpServer.registerTool(getStoragePoolTool.name, getStoragePoolTool, getStoragePoolHandler);
+    mcpServer.registerTool(listStoragePoolsTool.name, listStoragePoolsTool, listStoragePoolsHandler);
+    mcpServer.registerTool(updateStoragePoolTool.name, updateStoragePoolTool, updateStoragePoolHandler);
+    mcpServer.registerTool(validateDirectoryServiceTool.name, validateDirectoryServiceTool, validateDirectoryServiceHandler);
+    // Register volume tools
+    mcpServer.registerTool(createVolumeTool.name, createVolumeTool, createVolumeHandler);
+    mcpServer.registerTool(deleteVolumeTool.name, deleteVolumeTool, deleteVolumeHandler);
+    mcpServer.registerTool(getVolumeTool.name, getVolumeTool, getVolumeHandler);
+    mcpServer.registerTool(listVolumesTool.name, listVolumesTool, listVolumesHandler);
+    mcpServer.registerTool(updateVolumeTool.name, updateVolumeTool, updateVolumeHandler);
+    // Register snapshot tools
+    mcpServer.registerTool(createSnapshotTool.name, createSnapshotTool, createSnapshotHandler);
+    mcpServer.registerTool(deleteSnapshotTool.name, deleteSnapshotTool, deleteSnapshotHandler);
+    mcpServer.registerTool(getSnapshotTool.name, getSnapshotTool, getSnapshotHandler);
+    mcpServer.registerTool(listSnapshotsTool.name, listSnapshotsTool, listSnapshotsHandler);
+    mcpServer.registerTool(revertVolumeToSnapshotTool.name, revertVolumeToSnapshotTool, revertVolumeToSnapshotHandler);
+    mcpServer.registerTool(updateSnapshotTool.name, updateSnapshotTool, updateSnapshotHandler);
+    // Register backup vault tools
+    mcpServer.registerTool(createBackupVaultTool.name, createBackupVaultTool, createBackupVaultHandler);
+    mcpServer.registerTool(deleteBackupVaultTool.name, deleteBackupVaultTool, deleteBackupVaultHandler);
+    mcpServer.registerTool(getBackupVaultTool.name, getBackupVaultTool, getBackupVaultHandler);
+    mcpServer.registerTool(listBackupVaultsTool.name, listBackupVaultsTool, listBackupVaultsHandler);
+    mcpServer.registerTool(updateBackupVaultTool.name, updateBackupVaultTool, updateBackupVaultHandler);
+    // Register backup tools
+    mcpServer.registerTool(createBackupTool.name, createBackupTool, createBackupHandler);
+    mcpServer.registerTool(deleteBackupTool.name, deleteBackupTool, deleteBackupHandler);
+    mcpServer.registerTool(getBackupTool.name, getBackupTool, getBackupHandler);
+    mcpServer.registerTool(listBackupsTool.name, listBackupsTool, listBackupsHandler);
+    mcpServer.registerTool(restoreBackupTool.name, restoreBackupTool, restoreBackupHandler);
+    mcpServer.registerTool(updateBackupTool.name, updateBackupTool, updateBackupHandler);
+    // Register operation tools
+    mcpServer.registerTool(getOperationTool.name, getOperationTool, getOperationHandler);
+    mcpServer.registerTool(cancelOperationTool.name, cancelOperationTool, cancelOperationHandler);
+    mcpServer.registerTool(listOperationsTool.name, listOperationsTool, listOperationsHandler);
+    // Register backup policy tools
+    mcpServer.registerTool(createBackupPolicyTool.name, createBackupPolicyTool, backupPolicyHandlers[createBackupPolicyTool.name]);
+    mcpServer.registerTool(deleteBackupPolicyTool.name, deleteBackupPolicyTool, backupPolicyHandlers[deleteBackupPolicyTool.name]);
+    mcpServer.registerTool(getBackupPolicyTool.name, getBackupPolicyTool, backupPolicyHandlers[getBackupPolicyTool.name]);
+    mcpServer.registerTool(listBackupPoliciesTool.name, listBackupPoliciesTool, backupPolicyHandlers[listBackupPoliciesTool.name]);
+    mcpServer.registerTool(updateBackupPolicyTool.name, updateBackupPolicyTool, backupPolicyHandlers[updateBackupPolicyTool.name]);
+    // Register replication tools
+    mcpServer.registerTool(createReplicationTool.name, createReplicationTool, createReplicationHandler);
+    mcpServer.registerTool(deleteReplicationTool.name, deleteReplicationTool, deleteReplicationHandler);
+    mcpServer.registerTool(getReplicationTool.name, getReplicationTool, getReplicationHandler);
+    mcpServer.registerTool(listReplicationsTool.name, listReplicationsTool, listReplicationsHandler);
+    mcpServer.registerTool(updateReplicationTool.name, updateReplicationTool, updateReplicationHandler);
+    mcpServer.registerTool(resumeReplicationTool.name, resumeReplicationTool, resumeReplicationHandler);
+    mcpServer.registerTool(stopReplicationTool.name, stopReplicationTool, stopReplicationHandler);
+    mcpServer.registerTool(reverseReplicationDirectionTool.name, reverseReplicationDirectionTool, reverseReplicationDirectionHandler);
+    mcpServer.registerTool(establishPeeringTool.name, establishPeeringTool, establishPeeringHandler);
+    mcpServer.registerTool(syncReplicationTool.name, syncReplicationTool, syncReplicationHandler);
+    // Register active directory tools
+    mcpServer.registerTool(createActiveDirectoryTool.name, createActiveDirectoryTool, createActiveDirectoryHandler);
+    mcpServer.registerTool(deleteActiveDirectoryTool.name, deleteActiveDirectoryTool, deleteActiveDirectoryHandler);
+    mcpServer.registerTool(getActiveDirectoryTool.name, getActiveDirectoryTool, getActiveDirectoryHandler);
+    mcpServer.registerTool(listActiveDirectoriesTool.name, listActiveDirectoriesTool, listActiveDirectoriesHandler);
+    mcpServer.registerTool(updateActiveDirectoryTool.name, updateActiveDirectoryTool, updateActiveDirectoryHandler);
+    // Register KMS config tools
+    mcpServer.registerTool(createKmsConfigTool.name, createKmsConfigTool, createKmsConfigHandler);
+    mcpServer.registerTool(deleteKmsConfigTool.name, deleteKmsConfigTool, deleteKmsConfigHandler);
+    mcpServer.registerTool(getKmsConfigTool.name, getKmsConfigTool, getKmsConfigHandler);
+    mcpServer.registerTool(listKmsConfigsTool.name, listKmsConfigsTool, listKmsConfigsHandler);
+    mcpServer.registerTool(updateKmsConfigTool.name, updateKmsConfigTool, updateKmsConfigHandler);
+    mcpServer.registerTool(verifyKmsConfigTool.name, verifyKmsConfigTool, verifyKmsConfigHandler);
+    mcpServer.registerTool(encryptVolumesTool.name, encryptVolumesTool, encryptVolumesHandler);
+    // Register quota rule tools
+    mcpServer.registerTool(createQuotaRuleTool.name, createQuotaRuleTool, createQuotaRuleHandler);
+    mcpServer.registerTool(deleteQuotaRuleTool.name, deleteQuotaRuleTool, deleteQuotaRuleHandler);
+    mcpServer.registerTool(getQuotaRuleTool.name, getQuotaRuleTool, getQuotaRuleHandler);
+    mcpServer.registerTool(listQuotaRulesTool.name, listQuotaRulesTool, listQuotaRulesHandler);
+    mcpServer.registerTool(updateQuotaRuleTool.name, updateQuotaRuleTool, updateQuotaRuleHandler);
+}

package/build/registry/tool-registry.js

@@ -0,0 +1,27 @@
+/**
+ * Tool Registry for GCNV MCP Server
+ * Registers all available tools and their handlers
+ */
+// Registry of all tools
+export const toolRegistry = {};
+// Map of tool names to handler functions
+const toolHandlers = {};
+/**
+ * Register a tool and its handler in the registry
+ */
+export function registerTool(tool, handler) {
+    toolRegistry[tool.name] = tool;
+    toolHandlers[tool.name] = handler;
+}
+/**
+ * Get all tool definitions
+ */
+export function getAllToolDefinitions() {
+    return Object.values(toolRegistry);
+}
+/**
+ * Get a handler function for a tool
+ */
+export function getToolHandler(toolName) {
+    return toolHandlers[toolName];
+}

package/build/tools/active-directory-tools.js

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+// Create Active Directory Tool
+export const createActiveDirectoryTool = {
+    name: 'gcnv_active_directory_create',
+    title: 'Create Active Directory',
+    description: 'Creates a new active directory configuration',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location where the active directory should be created'),
+        activeDirectoryId: z.string().describe('The ID to assign to the active directory'),
+        domain: z.string().optional().describe('Domain name'),
+        site: z.string().optional().describe('Site name'),
+        dns: z.string().optional().describe('DNS server address'),
+        netBiosPrefix: z.string().optional().describe('NetBIOS prefix'),
+        organizationalUnit: z.string().optional().describe('Organizational unit'),
+        aesEncryption: z.boolean().optional().describe('Enable AES encryption'),
+        username: z.string().optional().describe('Username for domain join'),
+        password: z.string().optional().describe('Password for domain join'),
+        backupOperators: z.array(z.string()).optional().describe('List of backup operators'),
+        securityOperators: z.array(z.string()).optional().describe('List of security operators'),
+        kdcHostname: z.string().optional().describe('KDC hostname'),
+        kdcIp: z.string().optional().describe('KDC IP address'),
+        nfsUsersWithLdap: z.boolean().optional().describe('Enable NFS users with LDAP'),
+        description: z.string().optional().describe('Optional description'),
+        labels: z.record(z.string()).optional().describe('Optional labels'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the created active directory'),
+        operationId: z.string().describe('The ID of the long-running operation'),
+    },
+};
+// Delete Active Directory Tool
+export const deleteActiveDirectoryTool = {
+    name: 'gcnv_active_directory_delete',
+    title: 'Delete Active Directory',
+    description: 'Deletes an active directory configuration',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the active directory'),
+        activeDirectoryId: z.string().describe('The ID of the active directory to delete'),
+    },
+    outputSchema: {
+        success: z.boolean().describe('Whether the deletion was successful'),
+        operationId: z.string().optional().describe('The ID of the long-running operation'),
+    },
+};
+// Get Active Directory Tool
+export const getActiveDirectoryTool = {
+    name: 'gcnv_active_directory_get',
+    title: 'Get Active Directory',
+    description: 'Gets details of a specific active directory',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the active directory'),
+        activeDirectoryId: z.string().describe('The ID of the active directory to retrieve'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the active directory'),
+        activeDirectoryId: z.string().describe('The ID of the active directory'),
+        domain: z.string().optional().describe('Domain name'),
+        site: z.string().optional().describe('Site name'),
+        dns: z.string().optional().describe('DNS server address'),
+        state: z.string().optional().describe('The current state'),
+        createTime: z.date().optional().describe('The creation timestamp'),
+        description: z.string().optional().describe('Description'),
+        labels: z.record(z.string()).optional().describe('Labels'),
+    },
+};
+// List Active Directories Tool
+export const listActiveDirectoriesTool = {
+    name: 'gcnv_active_directory_list',
+    title: 'List Active Directories',
+    description: 'Lists all active directories in the specified location',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location to list active directories from'),
+        filter: z.string().optional().describe('Filter expression'),
+        pageSize: z.number().optional().describe('Maximum number of items to return'),
+        pageToken: z.string().optional().describe('Page token from previous request'),
+    },
+    outputSchema: {
+        activeDirectories: z
+            .array(z.object({
+            name: z.string().describe('The name of the active directory'),
+            activeDirectoryId: z.string().describe('The ID of the active directory'),
+            domain: z.string().optional().describe('Domain name'),
+            site: z.string().optional().describe('Site name'),
+            state: z.string().optional().describe('The current state'),
+            createTime: z.date().optional().describe('The creation timestamp'),
+        }))
+            .describe('List of active directories'),
+        nextPageToken: z.string().optional().describe('Token for next page'),
+    },
+};
+// Update Active Directory Tool
+export const updateActiveDirectoryTool = {
+    name: 'gcnv_active_directory_update',
+    title: 'Update Active Directory',
+    description: 'Updates an active directory configuration',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the active directory'),
+        activeDirectoryId: z.string().describe('The ID of the active directory to update'),
+        domain: z.string().optional().describe('Domain name'),
+        site: z.string().optional().describe('Site name'),
+        dns: z.string().optional().describe('DNS server address'),
+        netBiosPrefix: z.string().optional().describe('NetBIOS prefix'),
+        organizationalUnit: z.string().optional().describe('Organizational unit'),
+        aesEncryption: z.boolean().optional().describe('Enable AES encryption'),
+        username: z.string().optional().describe('Username for domain join'),
+        password: z.string().optional().describe('Password for domain join'),
+        backupOperators: z.array(z.string()).optional().describe('List of backup operators'),
+        securityOperators: z.array(z.string()).optional().describe('List of security operators'),
+        kdcHostname: z.string().optional().describe('KDC hostname'),
+        kdcIp: z.string().optional().describe('KDC IP address'),
+        nfsUsersWithLdap: z.boolean().optional().describe('Enable NFS users with LDAP'),
+        description: z.string().optional().describe('New description'),
+        labels: z.record(z.string()).optional().describe('New labels'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the updated active directory'),
+        operationId: z.string().describe('The ID of the long-running operation'),
+    },
+};

package/build/tools/backup-policy-tools.js

@@ -0,0 +1,140 @@
+import { z } from 'zod';
+// Create Backup Policy Tool
+export const createBackupPolicyTool = {
+    name: 'gcnv_backup_policy_create',
+    title: 'Create Backup Policy',
+    description: 'Creates a new backup policy in the specified project and location',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location where the backup policy should be created'),
+        backupPolicyId: z.string().describe('The ID to assign to the backup policy'),
+        dailyBackupLimit: z.number().optional().describe('Maximum number of daily backups to keep'),
+        weeklyBackupLimit: z.number().optional().describe('Maximum number of weekly backups to keep'),
+        monthlyBackupLimit: z.number().optional().describe('Maximum number of monthly backups to keep'),
+        description: z.string().optional().describe('Optional description of the backup policy'),
+        enabled: z.boolean().optional().describe('Whether the backup policy is enabled'),
+        labels: z
+            .record(z.string())
+            .optional()
+            .describe('Optional labels to apply to the backup policy'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the created backup policy'),
+        operationId: z
+            .string()
+            .describe('The ID of the long-running operation for creating the backup policy'),
+    },
+};
+// Delete Backup Policy Tool
+export const deleteBackupPolicyTool = {
+    name: 'gcnv_backup_policy_delete',
+    title: 'Delete Backup Policy',
+    description: 'Deletes a backup policy in the specified project and location',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the backup policy'),
+        backupPolicyId: z.string().describe('The ID of the backup policy to delete'),
+        force: z
+            .boolean()
+            .optional()
+            .describe('Force deletion even if the policy is assigned to volumes'),
+    },
+    outputSchema: {
+        success: z.boolean().describe('Whether the deletion was successful'),
+        operationId: z.string().optional().describe('The ID of the long-running operation'),
+    },
+};
+// Get Backup Policy Tool
+export const getBackupPolicyTool = {
+    name: 'gcnv_backup_policy_get',
+    title: 'Get Backup Policy',
+    description: 'Gets details of a specific backup policy',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the backup policy'),
+        backupPolicyId: z.string().describe('The ID of the backup policy to retrieve'),
+    },
+    outputSchema: {
+        name: z.string().describe('The fully qualified name of the backup policy'),
+        backupPolicyId: z.string().describe('The ID of the backup policy'),
+        dailyBackupLimit: z.number().optional().describe('Maximum number of daily backups to keep'),
+        weeklyBackupLimit: z.number().optional().describe('Maximum number of weekly backups to keep'),
+        monthlyBackupLimit: z.number().optional().describe('Maximum number of monthly backups to keep'),
+        description: z.string().optional().describe('Description of the backup policy'),
+        enabled: z.boolean().describe('Whether the backup policy is enabled'),
+        assignedVolumeCount: z
+            .number()
+            .optional()
+            .describe('Number of volumes assigned to this policy'),
+        state: z.string().describe('The current state of the backup policy'),
+        createTime: z.date().describe('The creation time of the backup policy'),
+        labels: z.record(z.string()).optional().describe('Labels applied to the backup policy'),
+    },
+};
+// List Backup Policies Tool
+export const listBackupPoliciesTool = {
+    name: 'gcnv_backup_policy_list',
+    title: 'List Backup Policies',
+    description: 'Lists backup policies in a specific project and location',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location to list backup policies from'),
+        filter: z.string().optional().describe('Filter expression for filtering results'),
+        pageSize: z
+            .number()
+            .optional()
+            .describe('Maximum number of backup policies to return per page'),
+        pageToken: z.string().optional().describe('Page token from a previous list request'),
+    },
+    outputSchema: {
+        backupPolicies: z
+            .array(z.object({
+            name: z.string().describe('The fully qualified name of the backup policy'),
+            backupPolicyId: z.string().describe('The ID of the backup policy'),
+            dailyBackupLimit: z
+                .number()
+                .optional()
+                .describe('Maximum number of daily backups to keep'),
+            weeklyBackupLimit: z
+                .number()
+                .optional()
+                .describe('Maximum number of weekly backups to keep'),
+            monthlyBackupLimit: z
+                .number()
+                .optional()
+                .describe('Maximum number of monthly backups to keep'),
+            description: z.string().optional().describe('Description of the backup policy'),
+            enabled: z.boolean().describe('Whether the backup policy is enabled'),
+            assignedVolumeCount: z
+                .number()
+                .optional()
+                .describe('Number of volumes assigned to this policy'),
+            state: z.string().describe('The current state of the backup policy'),
+            createTime: z.date().optional().describe('The creation time of the backup policy'),
+            labels: z.record(z.string()).optional().describe('Labels applied to the backup policy'),
+        }))
+            .describe('List of backup policies'),
+        nextPageToken: z.string().optional().describe('Token for fetching the next page'),
+    },
+};
+// Update Backup Policy Tool
+export const updateBackupPolicyTool = {
+    name: 'gcnv_backup_policy_update',
+    title: 'Update Backup Policy',
+    description: 'Updates the properties of an existing backup policy',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the backup policy'),
+        backupPolicyId: z.string().describe('The ID of the backup policy to update'),
+        dailyBackupLimit: z.number().optional().describe('Maximum number of daily backups to keep'),
+        weeklyBackupLimit: z.number().optional().describe('Maximum number of weekly backups to keep'),
+        monthlyBackupLimit: z.number().optional().describe('Maximum number of monthly backups to keep'),
+        description: z.string().optional().describe('New description for the backup policy'),
+        enabled: z.boolean().optional().describe('Whether the backup policy is enabled'),
+        labels: z.record(z.string()).optional().describe('New labels to apply to the backup policy'),
+    },
+    outputSchema: {
+        name: z.string().describe('The fully qualified name of the updated backup policy'),
+        operationId: z.string().describe('The ID of the long-running operation'),
+    },
+};

package/build/tools/backup-tools.js

@@ -0,0 +1,178 @@
+import { z } from 'zod';
+// Create Backup Tool
+export const createBackupTool = {
+    name: 'gcnv_backup_create',
+    title: 'Create Backup',
+    description: 'Creates a new backup of a volume in the specified backup vault',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location where the backup should be created'),
+        backupVaultId: z.string().describe('The ID of the backup vault to store the backup'),
+        backupId: z.string().describe('The ID to assign to the backup'),
+        backupRegion: z.string().optional().describe('The region where the backup will be stored'),
+        enforcedRetentionEndTime: z
+            .number()
+            .optional()
+            .describe('The number of days to retain the backup'),
+        sourceVolumeName: z
+            .string()
+            .describe('The full name of the volume to back up (projects/{project}/locations/{location}/storagePools/{storage_pool}/volumes/{volume})'),
+        description: z.string().optional().describe('Optional description of the backup'),
+        labels: z.record(z.string()).optional().describe('Optional labels to apply to the backup'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the created backup'),
+        operationId: z
+            .string()
+            .describe('The ID of the long-running operation for creating the backup'),
+    },
+};
+// Delete Backup Tool
+export const deleteBackupTool = {
+    name: 'gcnv_backup_delete',
+    title: 'Delete Backup',
+    description: 'Deletes a backup from the specified backup vault',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the backup'),
+        backupVaultId: z.string().describe('The ID of the backup vault containing the backup'),
+        backupId: z.string().describe('The ID of the backup to delete'),
+    },
+    outputSchema: {
+        success: z.boolean().describe('Whether the deletion was successful'),
+        operationId: z.string().optional().describe('The ID of the long-running operation'),
+    },
+};
+// Get Backup Tool
+export const getBackupTool = {
+    name: 'gcnv_backup_get',
+    title: 'Get Backup',
+    description: 'Gets details of a specific backup',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the backup'),
+        backupVaultId: z.string().describe('The ID of the backup vault containing the backup'),
+        backupId: z.string().describe('The ID of the backup to retrieve'),
+    },
+    outputSchema: {
+        name: z.string().describe('The fully qualified name of the backup'),
+        backupId: z.string().describe('The ID of the backup'),
+        backupVaultId: z.string().describe('The ID of the backup vault containing the backup'),
+        state: z.string().describe('The current state of the backup'),
+        description: z.string().optional().describe('Description of the backup'),
+        volumeUsagebytes: z.number().optional().describe('The size of the volume in bytes'),
+        backupType: z.string().optional().describe('The type of the backup'),
+        sourceVolume: z.string().describe('The name of the source volume'),
+        createTime: z.date().optional().describe('The creation time of the backup'),
+        chainStoragebytes: z.number().optional().describe('The size of the backup chain in bytes'),
+        satisfiesPzs: z.boolean().optional().describe('Whether the backup satisfies PZS requirements'),
+        satisfiesPzi: z.boolean().optional().describe('Whether the backup satisfies PZI requirements'),
+        volumeRegion: z.string().optional().describe('The region of the source volume'),
+        backupRegion: z.string().optional().describe('The region where the backup is stored'),
+        enforcedRetentionEndTime: z
+            .number()
+            .optional()
+            .describe('The number of days the backup is retained'),
+        sourceSnapshot: z
+            .string()
+            .optional()
+            .describe('The name of the source snapshot if the backup was created from a snapshot'),
+        labels: z.record(z.string()).optional().describe('Labels applied to the backup'),
+    },
+};
+// List Backups Tool
+export const listBackupsTool = {
+    name: 'gcnv_backup_list',
+    title: 'List Backups',
+    description: 'Lists backups in a specific backup vault',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location to list backups from'),
+        backupVaultId: z.string().describe('The ID of the backup vault containing the backups'),
+        filter: z.string().optional().describe('Filter expression for filtering results'),
+        pageSize: z.number().optional().describe('Maximum number of backups to return per page'),
+        pageToken: z.string().optional().describe('Page token from a previous list request'),
+    },
+    outputSchema: {
+        backups: z
+            .array(z.object({
+            name: z.string().describe('The fully qualified name of the backup'),
+            backupId: z.string().describe('The ID of the backup'),
+            backupVaultId: z.string().describe('The ID of the backup vault containing the backup'),
+            state: z.string().describe('The current state of the backup'),
+            description: z.string().optional().describe('Description of the backup'),
+            volumeUsagebytes: z.number().optional().describe('The size of the volume in bytes'),
+            backupType: z.string().optional().describe('The type of the backup'),
+            sourceVolume: z.string().describe('The name of the source volume'),
+            createTime: z.date().optional().describe('The creation time of the backup'),
+            chainStoragebytes: z
+                .number()
+                .optional()
+                .describe('The size of the backup chain in bytes'),
+            satisfiesPzs: z
+                .boolean()
+                .optional()
+                .describe('Whether the backup satisfies PZS requirements'),
+            satisfiesPzi: z
+                .boolean()
+                .optional()
+                .describe('Whether the backup satisfies PZI requirements'),
+            volumeRegion: z.string().optional().describe('The region of the source volume'),
+            backupRegion: z.string().optional().describe('The region where the backup is stored'),
+            enforcedRetentionEndTime: z
+                .number()
+                .optional()
+                .describe('The number of days the backup is retained'),
+            sourceSnapshot: z
+                .string()
+                .optional()
+                .describe('The name of the source snapshot if the backup was created from a snapshot'),
+            labels: z.record(z.string()).optional().describe('Labels applied to the backup'),
+        }))
+            .describe('List of backups'),
+        nextPageToken: z.string().optional().describe('Token for fetching the next page'),
+    },
+};
+// Restore Backup Tool
+export const restoreBackupTool = {
+    name: 'gcnv_backup_restore',
+    title: 'Restore Backup',
+    description: 'Restores a backup to a new or existing volume',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the backup'),
+        backupVaultId: z.string().describe('The ID of the backup vault containing the backup'),
+        backupId: z.string().describe('The ID of the backup to restore'),
+        targetStoragePoolId: z.string().describe('The ID of the storage pool to restore to'),
+        targetVolumeId: z.string().describe('The ID of the target volume to create or overwrite'),
+        restoreOption: z
+            .enum(['CREATE_NEW_VOLUME', 'OVERWRITE_EXISTING_VOLUME'])
+            .describe('Whether to create a new volume or overwrite an existing one'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the target volume'),
+        operationId: z
+            .string()
+            .describe('The ID of the long-running operation for restoring the backup'),
+    },
+};
+// Update Backup Tool
+export const updateBackupTool = {
+    name: 'gcnv_backup_update',
+    title: 'Update Backup',
+    description: 'Updates a backup with full spec',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the backup'),
+        backupVaultId: z.string().describe('The ID of the backup vault containing the backup'),
+        backupId: z.string().describe('The ID of the backup to update'),
+        description: z.string().optional().describe('New description of the backup'),
+        labels: z.record(z.string()).optional().describe('New labels to apply to the backup'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the updated backup'),
+        operationId: z
+            .string()
+            .describe('The ID of the long-running operation for updating the backup'),
+    },
+};