@gcnv/gcnv-mcp-server 1.0.3

package/build/tools/handlers/volume-handler.js

@@ -0,0 +1,353 @@
+import { NetAppClientFactory } from '../../utils/netapp-client-factory.js';
+import { logger } from '../../logger.js';
+const log = logger.child({ module: 'volume-handler' });
+// Helper to format volume data for responses
+function formatVolumeData(volume) {
+    const result = {};
+    if (!volume)
+        return result;
+    if (volume.name) {
+        // Extract volumeId from name (last part after last slash)
+        const nameParts = volume.name.split('/');
+        result.name = volume.name;
+        result.volumeId = nameParts[nameParts.length - 1];
+    }
+    // Extract storage pool from name
+    if (volume.storagePool) {
+        result.storagePool = volume.storagePool;
+    }
+    // Copy basic properties
+    if (volume.capacityGib)
+        result.capacityGib = Number(volume.capacityGib);
+    if (volume.usedGib)
+        result.usedGib = Number(volume.usedGib);
+    if (volume.state)
+        result.state = volume.state;
+    if (volume.stateDetails)
+        result.stateDetails = volume.stateDetails;
+    if (volume.shareName)
+        result.shareName = volume.shareName;
+    if (volume.protocols)
+        result.protocols = volume.protocols;
+    if (volume.serviceLevel)
+        result.serviceLevel = volume.serviceLevel;
+    if (volume.network)
+        result.network = volume.network;
+    if (volume.psaRange)
+        result.psaRange = volume.psaRange;
+    if (volume.securityStyle)
+        result.securityStyle = volume.securityStyle;
+    // Format timestamps if they exist
+    if (volume.createTime) {
+        result.createTime = new Date(volume.createTime.seconds * 1000);
+    }
+    // Copy optional properties
+    if (volume.description)
+        result.description = volume.description;
+    if (volume.labels)
+        result.labels = volume.labels;
+    if (volume.unixPermissions)
+        result.unixPermissions = volume.unixPermissions;
+    if (volume.kmsConfig)
+        result.kmsConfig = volume.kmsConfig;
+    if (volume.encryptionType)
+        result.encryptionType = volume.encryptionType;
+    if (volume.backupConfig)
+        result.backupConfig = volume.backupConfig;
+    if (volume.tieringPolicy)
+        result.tieringPolicy = volume.tieringPolicy;
+    if (volume.throughputMibps !== undefined)
+        result.throughputMibps = volume.throughputMibps;
+    if (volume.replicaZone)
+        result.replicaZone = volume.replicaZone;
+    if (volume.zone)
+        result.zone = volume.zone;
+    if (volume.coldTierSizeGib !== undefined)
+        result.coldTierSizeGib = Number(volume.coldTierSizeGib);
+    if (volume.hotTierSizeUsedGib !== undefined)
+        result.hotTierSizeUsedGib = Number(volume.hotTierSizeUsedGib);
+    if (volume.largeCapacity !== undefined)
+        result.largeCapacity = volume.largeCapacity;
+    if (volume.multipleEndpoints !== undefined)
+        result.multipleEndpoints = volume.multipleEndpoints;
+    if (volume.hasReplication !== undefined)
+        result.hasReplication = volume.hasReplication;
+    if (volume.restrictedActions)
+        result.restrictedActions = volume.restrictedActions;
+    // Format mount points
+    if (volume.mountOptions && volume.mountOptions.length > 0) {
+        result.mountOptions = volume.mountOptions.map((mp) => ({
+            protocol: mp.protocol || '',
+            ipAddress: mp.ipAddress || '',
+            export: mp.export || '',
+            exportFull: mp.exportFull || '',
+        }));
+    }
+    // Surface export policy if present
+    if (volume.exportPolicy)
+        result.exportPolicy = volume.exportPolicy;
+    // Surface SMB settings if present
+    if (volume.smbSettings)
+        result.smbSettings = volume.smbSettings;
+    return result;
+}
+// Create Volume Handler
+export const createVolumeHandler = async (args) => {
+    try {
+        const { projectId, location, storagePoolId, volumeId, capacityGib, protocols, description, labels, backupConfig, exportPolicy, shareName, } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the parent path for the volume
+        const parent = `projects/${projectId}/locations/${location}`;
+        // Create the volume request
+        const request = {
+            parent,
+            volumeId,
+            volume: {
+                storagePool: storagePoolId,
+                capacityGib,
+                protocols: protocols || ['NFS3'],
+                description,
+                labels,
+                backupConfig,
+                shareName: shareName || volumeId,
+                exportPolicy,
+            },
+        };
+        log.info({ request }, 'Create Volume request');
+        // Call the API to create a volume
+        const [operation] = await netAppClient.createVolume(request);
+        log.info({ operation }, 'Create Volume operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Created volume ${volumeId}. Operation ID: ${operation.name || ''}`,
+                },
+            ],
+            structuredContent: {
+                name: `projects/${projectId}/locations/${location}/volumes/${volumeId}`,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error creating volume');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error creating volume: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Delete Volume Handler
+export const deleteVolumeHandler = async (args) => {
+    try {
+        const { projectId, location, volumeId, force = false } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the volume
+        const name = `projects/${projectId}/locations/${location}/volumes/${volumeId}`;
+        // Call the API to delete the volume
+        const request = { name };
+        // Only add force if it's true to avoid API errors
+        if (force) {
+            request.force = true;
+        }
+        log.info({ request }, 'Delete Volume request');
+        const [operation] = await netAppClient.deleteVolume(request);
+        log.info({ operation }, 'Delete Volume operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        message: `Volume ${volumeId} deletion requested`,
+                        operation: operation,
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                success: true,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error deleting volume');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error deleting volume: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            structuredContent: {
+                success: false,
+            },
+        };
+    }
+};
+// Get Volume Handler
+export const getVolumeHandler = async (args) => {
+    try {
+        const { projectId, location, volumeId } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the volume
+        const name = `projects/${projectId}/locations/${location}/volumes/${volumeId}`;
+        // Call the API to get the volume
+        log.info({ name }, 'Get Volume request');
+        const [volume] = await netAppClient.getVolume({ name });
+        log.info({ volume }, 'Get Volume response');
+        // Format the volume data
+        const formattedVolume = formatVolumeData(volume);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(volume, null, 2),
+                },
+            ],
+            structuredContent: { volume: formattedVolume },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error getting volume');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error getting volume: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// List Volumes Handler
+export const listVolumesHandler = async (args) => {
+    try {
+        const { projectId, location, filter, pageSize, pageToken } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the parent path
+        const parent = `projects/${projectId}/locations/${location}`;
+        // Create the request object
+        const request = { parent };
+        if (filter)
+            request.filter = filter;
+        if (pageSize)
+            request.pageSize = pageSize;
+        if (pageToken)
+            request.pageToken = pageToken;
+        // Call the API to list volumes
+        log.info({ request }, 'List Volumes request');
+        const [volumes, , nextPageToken] = await netAppClient.listVolumes(request);
+        log.info({ volumes, nextPageToken }, 'List Volumes response');
+        const formattedVolumes = volumes.map(formatVolumeData);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ volumes: volumes, nextPageToken: nextPageToken }, null, 2),
+                },
+            ],
+            structuredContent: {
+                volumes: formattedVolumes,
+                nextPageToken: pageToken || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error listing volumes');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error listing volumes: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Update Volume Handler
+// TODO: update is not tested
+// FIX_ME: errors "reason: 'RESOURCE_PROJECT_INVALID'
+export const updateVolumeHandler = async (args) => {
+    try {
+        const { projectId, location, volumeId, capacityGib, description, labels, backupConfig, exportPolicy, } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Format the name for the volume
+        const name = `projects/${projectId}/locations/${location}/volumes/${volumeId}`;
+        // Create the update mask
+        const updateMask = [];
+        const volume = { name };
+        // Add fields to update mask if they're provided
+        if (capacityGib !== undefined) {
+            volume.capacityGib = capacityGib;
+            updateMask.push('capacity_gib');
+        }
+        if (description !== undefined) {
+            volume.description = description;
+            updateMask.push('description');
+        }
+        if (labels !== undefined) {
+            volume.labels = labels;
+            updateMask.push('labels');
+        }
+        if (exportPolicy !== undefined) {
+            volume.exportPolicy = exportPolicy;
+            updateMask.push('export_policy');
+        }
+        if (backupConfig !== undefined) {
+            volume.backupConfig = backupConfig;
+            // Update mask must use proto (snake_case) field names
+            if (backupConfig.backupPolicies !== undefined)
+                updateMask.push('backup_config.backup_policies');
+            if (backupConfig.backupVault !== undefined)
+                updateMask.push('backup_config.backup_vault');
+            if (backupConfig.scheduledBackupEnabled !== undefined)
+                updateMask.push('backup_config.scheduled_backup_enabled');
+        }
+        // Create the request
+        const request = {
+            volume,
+            updateMask: { paths: updateMask },
+        };
+        log.info({ request }, 'Update Volume request');
+        const [operation] = await netAppClient.updateVolume(request);
+        log.info({ operation }, 'Update Volume operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Updated volume ${volumeId}. Operation ID: ${operation.name || ''}`,
+                },
+            ],
+            structuredContent: {
+                name,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error updating volume');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error updating volume: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};

package/build/tools/kms-config-tools.js

@@ -0,0 +1,162 @@
+import { z } from 'zod';
+// Create KMS Config Tool
+export const createKmsConfigTool = {
+    name: 'gcnv_kms_config_create',
+    title: 'Create KMS Config',
+    description: 'Creates a new KMS (Key Management Service) configuration',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location where the KMS config should be created'),
+        kmsConfigId: z.string().describe('The ID to assign to the KMS config'),
+        cryptoKeyName: z.string().describe('The full name of the crypto key'),
+        description: z.string().optional().describe('Optional description'),
+        labels: z.record(z.string()).optional().describe('Optional labels'),
+        instructions: z.string().optional().describe('Instructions for accessing the KMS'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the created KMS config'),
+        operationId: z.string().describe('The ID of the long-running operation'),
+    },
+};
+// Delete KMS Config Tool
+export const deleteKmsConfigTool = {
+    name: 'gcnv_kms_config_delete',
+    title: 'Delete KMS Config',
+    description: 'Deletes a KMS configuration',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the KMS config'),
+        kmsConfigId: z.string().describe('The ID of the KMS config 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 KMS Config Tool
+export const getKmsConfigTool = {
+    name: 'gcnv_kms_config_get',
+    title: 'Get KMS Config',
+    description: 'Gets details of a specific KMS configuration',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the KMS config'),
+        kmsConfigId: z.string().describe('The ID of the KMS config to retrieve'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the KMS config'),
+        kmsConfigId: z.string().describe('The ID of the KMS config'),
+        cryptoKeyName: z.string().optional().describe('The name of the crypto key'),
+        state: z
+            .string()
+            .optional()
+            .describe('The current state (e.g., READY, KEY_CHECK_PENDING—run instructions if pending)'),
+        instructions: z
+            .string()
+            .optional()
+            .describe('Steps to grant the service account access when state is KEY_CHECK_PENDING'),
+        stateDetails: z
+            .string()
+            .optional()
+            .describe('Additional state details when the KMS config is not ready'),
+        createTime: z.date().optional().describe('The creation timestamp'),
+        description: z.string().optional().describe('Description'),
+        labels: z.record(z.string()).optional().describe('Labels'),
+        serviceAccount: z
+            .string()
+            .optional()
+            .describe('Service account used by NetApp to access the KMS key'),
+    },
+};
+// List KMS Configs Tool
+export const listKmsConfigsTool = {
+    name: 'gcnv_kms_config_list',
+    title: 'List KMS Configs',
+    description: 'Lists all KMS configurations in the specified location',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location to list KMS configs 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'),
+        orderBy: z.string().optional().describe('Sort order'),
+    },
+    outputSchema: {
+        kmsConfigs: z
+            .array(z.object({
+            name: z.string().describe('The name of the KMS config'),
+            kmsConfigId: z.string().describe('The ID of the KMS config'),
+            cryptoKeyName: z.string().optional().describe('The name of the crypto key'),
+            state: z
+                .string()
+                .optional()
+                .describe('The current state (e.g., READY, KEY_CHECK_PENDING—run instructions if pending)'),
+            instructions: z
+                .string()
+                .optional()
+                .describe('Steps to grant the service account access when state is KEY_CHECK_PENDING'),
+            stateDetails: z
+                .string()
+                .optional()
+                .describe('Additional state details when the KMS config is not ready'),
+            createTime: z.date().optional().describe('The creation timestamp'),
+            description: z.string().optional().describe('Description'),
+            labels: z.record(z.string()).optional().describe('Labels'),
+            serviceAccount: z
+                .string()
+                .optional()
+                .describe('Service account used by NetApp to access the KMS key'),
+        }))
+            .describe('List of KMS configs'),
+        nextPageToken: z.string().optional().describe('Token for next page'),
+    },
+};
+// Update KMS Config Tool
+export const updateKmsConfigTool = {
+    name: 'gcnv_kms_config_update',
+    title: 'Update KMS Config',
+    description: 'Updates a KMS configuration',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the KMS config'),
+        kmsConfigId: z.string().describe('The ID of the KMS config to update'),
+        cryptoKeyName: z.string().optional().describe('The name of the crypto key'),
+        description: z.string().optional().describe('New description'),
+        labels: z.record(z.string()).optional().describe('New labels'),
+        instructions: z.string().optional().describe('Instructions for accessing the KMS'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the updated KMS config'),
+        operationId: z.string().describe('The ID of the long-running operation'),
+    },
+};
+// Verify KMS Config Tool
+export const verifyKmsConfigTool = {
+    name: 'gcnv_kms_config_verify',
+    title: 'Verify KMS Config',
+    description: 'Verifies KMS config reachability after granting CMEK permissions; run this after applying the returned instructions so the service marks the config READY for pool creation',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the KMS config'),
+        kmsConfigId: z.string().describe('The ID of the KMS config to verify'),
+    },
+    outputSchema: {
+        reachable: z.boolean().optional().describe('Whether the KMS config is reachable'),
+        healthError: z.string().optional().describe('Health error if any'),
+    },
+};
+// Encrypt Volumes Tool
+export const encryptVolumesTool = {
+    name: 'gcnv_kms_config_encrypt_volumes',
+    title: 'Encrypt Volumes',
+    description: 'Encrypts existing volumes without CMEK encryption with the desired KMS config',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the KMS config'),
+        kmsConfigId: z.string().describe('The ID of the KMS config to use for encryption'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the KMS config'),
+        operationId: z.string().describe('The ID of the long-running operation'),
+    },
+};

package/build/tools/operation-tools.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+// Get Operation Tool
+export const getOperationTool = {
+    name: 'gcnv_operation_get',
+    title: 'Get Operation',
+    description: 'Get details of a long-running operation by its ID',
+    inputSchema: {
+        operationName: z.string().describe('The full name of the operation to retrieve'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the operation'),
+        done: z.boolean().describe('Whether the operation is complete'),
+        success: z.boolean().describe('True when done is true; done determines the final result'),
+        metadata: z.record(z.any()).optional().describe('Metadata about the operation'),
+        error: z.record(z.any()).optional().describe('Error details if the operation failed'),
+        response: z.record(z.any()).optional().describe('The response if the operation succeeded'),
+        createTime: z.string().optional().describe('When the operation was created'),
+        target: z.string().optional().describe('The target resource of the operation'),
+        verb: z.string().optional().describe('The operation verb (create, update, delete)'),
+        statusMessage: z.string().optional().describe('Current status message of the operation'),
+        cancelRequested: z.boolean().optional().describe('Whether cancellation was requested'),
+        apiVersion: z.string().optional().describe('API version used for the operation'),
+    },
+};
+// Cancel Operation Tool
+export const cancelOperationTool = {
+    name: 'gcnv_operation_cancel',
+    title: 'Cancel Operation',
+    description: 'Cancels a long-running operation that is still in progress',
+    inputSchema: {
+        operationName: z.string().describe('The full name of the operation to cancel'),
+    },
+    outputSchema: {
+        success: z.boolean().describe('Whether the cancellation request was successful'),
+        message: z.string().describe('Status message about the cancellation attempt'),
+    },
+};
+// List Operations Tool
+export const listOperationsTool = {
+    name: 'gcnv_operation_list',
+    title: 'List Operations',
+    description: 'Lists all active long-running operations in the project',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location to list operations from'),
+        filter: z.string().optional().describe('Filter expression for operations'),
+        pageSize: z.number().optional().describe('The maximum number of operations to return'),
+        pageToken: z.string().optional().describe('Page token from a previous list request'),
+    },
+    outputSchema: {
+        operations: z
+            .array(z.object({
+            name: z.string().describe('The name of the operation'),
+            done: z.boolean().describe('Whether the operation is complete'),
+            success: z.boolean().describe('True when done is true; done determines the final result'),
+            target: z.string().optional().describe('The target resource of the operation'),
+            verb: z.string().optional().describe('The operation verb (create, update, delete)'),
+            createTime: z.string().optional().describe('When the operation was created'),
+            statusMessage: z.string().optional().describe('Current status message of the operation'),
+        }))
+            .describe('List of operations'),
+        nextPageToken: z.string().optional().describe('Token to retrieve the next page of results'),
+    },
+};