@gcnv/gcnv-mcp-server 1.0.3

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

@@ -0,0 +1,327 @@
+import { z } from 'zod';
+import { NetAppClientFactory } from '../../utils/netapp-client-factory.js';
+import { getKmsConfigTool, listKmsConfigsTool } from '../kms-config-tools.js';
+import { logger } from '../../logger.js';
+const log = logger.child({ module: 'kms-config-handler' });
+const getKmsConfigOutputSchema = z.object(getKmsConfigTool.outputSchema);
+const listKmsConfigsOutputSchema = z.object(listKmsConfigsTool.outputSchema);
+// Helper to format KMS config data
+function formatKmsConfigData(config) {
+    const result = {};
+    if (!config)
+        return result;
+    if (config.name) {
+        const nameParts = config.name.split('/');
+        result.name = config.name;
+        result.kmsConfigId = nameParts[nameParts.length - 1];
+    }
+    if (config.cryptoKeyName)
+        result.cryptoKeyName = config.cryptoKeyName;
+    if (config.state)
+        result.state = config.state;
+    if (config.stateDetails)
+        result.stateDetails = config.stateDetails;
+    if (config.instructions)
+        result.instructions = config.instructions;
+    if (config.serviceAccount)
+        result.serviceAccount = config.serviceAccount;
+    if (config.createTime) {
+        result.createTime = new Date(config.createTime.seconds * 1000);
+    }
+    if (config.description)
+        result.description = config.description;
+    if (config.labels)
+        result.labels = config.labels;
+    return result;
+}
+// Create KMS Config Handler
+export const createKmsConfigHandler = async (args) => {
+    try {
+        const { projectId, location, kmsConfigId, cryptoKeyName, description, labels, instructions } = args;
+        const netAppClient = NetAppClientFactory.createClient();
+        const parent = `projects/${projectId}/locations/${location}`;
+        const kmsConfig = {};
+        if (cryptoKeyName)
+            kmsConfig.cryptoKeyName = cryptoKeyName;
+        if (description)
+            kmsConfig.description = description;
+        if (labels)
+            kmsConfig.labels = labels;
+        if (instructions)
+            kmsConfig.instructions = instructions;
+        const request = {
+            parent,
+            kmsConfigId,
+            kmsConfig,
+        };
+        log.info({ request }, 'Create KMS Config request');
+        const [operation] = await netAppClient.createKmsConfig(request);
+        log.info({ operation }, 'Create KMS Config operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        name: `projects/${projectId}/locations/${location}/kmsConfigs/${kmsConfigId}`,
+                        operation: operation,
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                name: `projects/${projectId}/locations/${location}/kmsConfigs/${kmsConfigId}`,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error creating KMS config');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error creating KMS config: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Delete KMS Config Handler
+export const deleteKmsConfigHandler = async (args) => {
+    try {
+        const { projectId, location, kmsConfigId } = args;
+        const netAppClient = NetAppClientFactory.createClient();
+        const name = `projects/${projectId}/locations/${location}/kmsConfigs/${kmsConfigId}`;
+        const [operation] = await netAppClient.deleteKmsConfig({ name });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        message: `KMS config ${kmsConfigId} deletion requested`,
+                        operation: operation,
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                success: true,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error deleting KMS config');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error deleting KMS config: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Get KMS Config Handler
+export const getKmsConfigHandler = async (args) => {
+    try {
+        const { projectId, location, kmsConfigId } = args;
+        const netAppClient = NetAppClientFactory.createClient();
+        const name = `projects/${projectId}/locations/${location}/kmsConfigs/${kmsConfigId}`;
+        const [kmsConfig] = await netAppClient.getKmsConfig({ name });
+        const formatted = formatKmsConfigData(kmsConfig);
+        const structuredContent = getKmsConfigOutputSchema.parse(formatted);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(structuredContent, null, 2),
+                },
+            ],
+            structuredContent,
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error getting KMS config');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error getting KMS config: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// List KMS Configs Handler
+export const listKmsConfigsHandler = async (args) => {
+    try {
+        const { projectId, location, filter, pageSize, pageToken, orderBy } = args;
+        const netAppClient = NetAppClientFactory.createClient();
+        const parent = `projects/${projectId}/locations/${location}`;
+        const request = { parent };
+        if (filter)
+            request.filter = filter;
+        if (pageSize)
+            request.pageSize = pageSize;
+        if (pageToken)
+            request.pageToken = pageToken;
+        if (orderBy)
+            request.orderBy = orderBy;
+        const [kmsConfigs, , response] = await netAppClient.listKmsConfigs(request);
+        const structuredContent = listKmsConfigsOutputSchema.parse({
+            kmsConfigs: kmsConfigs.map(formatKmsConfigData),
+            nextPageToken: response?.nextPageToken,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(structuredContent, null, 2),
+                },
+            ],
+            structuredContent,
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error listing KMS configs');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error listing KMS configs: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Update KMS Config Handler
+export const updateKmsConfigHandler = async (args) => {
+    try {
+        const { projectId, location, kmsConfigId, cryptoKeyName, description, labels, instructions } = args;
+        const netAppClient = NetAppClientFactory.createClient();
+        const name = `projects/${projectId}/locations/${location}/kmsConfigs/${kmsConfigId}`;
+        const updateMask = [];
+        const kmsConfig = { name };
+        if (cryptoKeyName !== undefined) {
+            kmsConfig.cryptoKeyName = cryptoKeyName;
+            updateMask.push('crypto_key_name');
+        }
+        if (description !== undefined) {
+            kmsConfig.description = description;
+            updateMask.push('description');
+        }
+        if (labels !== undefined) {
+            kmsConfig.labels = labels;
+            updateMask.push('labels');
+        }
+        if (instructions !== undefined) {
+            kmsConfig.instructions = instructions;
+            updateMask.push('instructions');
+        }
+        const request = {
+            kmsConfig,
+            updateMask: { paths: updateMask },
+        };
+        log.info({ request }, 'Update KMS Config request');
+        const [operation] = await netAppClient.updateKmsConfig(request);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        message: `KMS config ${kmsConfigId} update requested`,
+                        operation: operation,
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                name: name,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error updating KMS config');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error updating KMS config: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Verify KMS Config Handler
+export const verifyKmsConfigHandler = async (args) => {
+    try {
+        const { projectId, location, kmsConfigId } = args;
+        const netAppClient = NetAppClientFactory.createClient();
+        const name = `projects/${projectId}/locations/${location}/kmsConfigs/${kmsConfigId}`;
+        const [response] = await netAppClient.verifyKmsConfig({ name });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(response, null, 2),
+                },
+            ],
+            structuredContent: {
+                reachable: response.healthy,
+                healthError: response.healthError,
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error verifying KMS config');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error verifying KMS config: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Encrypt Volumes Handler
+export const encryptVolumesHandler = async (args) => {
+    try {
+        const { projectId, location, kmsConfigId } = args;
+        const netAppClient = NetAppClientFactory.createClient();
+        const name = `projects/${projectId}/locations/${location}/kmsConfigs/${kmsConfigId}`;
+        const [operation] = await netAppClient.encryptVolumes({ name });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        message: `Volume encryption initiated for KMS config ${kmsConfigId}`,
+                        operation: operation,
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                name: name,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error encrypting volumes');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error encrypting volumes: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};

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

@@ -0,0 +1,254 @@
+import { NetAppClientFactory } from '../../utils/netapp-client-factory.js';
+import axios from 'axios';
+import { logger } from '../../logger.js';
+const log = logger.child({ module: 'operation-handler' });
+/**
+ * Parse metadata from a Google Cloud operation
+ * @param operation The operation object
+ * @returns Formatted metadata
+ */
+function parseOperationMetadata(operation) {
+    const done = operation.done === true;
+    const result = {
+        name: operation.name || '',
+        done,
+        success: done,
+    };
+    // Try to get metadata from the operation
+    if (operation.metadata) {
+        try {
+            // Add metadata as-is to the result
+            result.metadata = operation.metadata;
+            // Try to extract specific fields that might be useful
+            const metadata = operation.metadata;
+            if (metadata.createTime) {
+                result.createTime = metadata.createTime;
+            }
+            // These fields might be present depending on the operation type
+            if (metadata.target)
+                result.target = metadata.target;
+            if (metadata.verb)
+                result.verb = metadata.verb;
+            if (metadata.statusMessage)
+                result.statusMessage = metadata.statusMessage;
+            if (metadata.apiVersion)
+                result.apiVersion = metadata.apiVersion;
+            if (metadata.requestedCancellation !== undefined) {
+                result.cancelRequested = metadata.requestedCancellation;
+            }
+        }
+        catch (err) {
+            log.warn({ err }, 'Error parsing operation metadata');
+        }
+    }
+    // Add error information if operation failed
+    if (operation.done && operation.error) {
+        result.error = {
+            code: operation.error.code,
+            message: operation.error.message,
+        };
+    }
+    // Add response data if operation succeeded
+    if (operation.done && operation.response) {
+        result.response = operation.response;
+    }
+    return result;
+}
+// Get Operation Handler
+export const getOperationHandler = async (args) => {
+    try {
+        const { operationName } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Make a direct request to the operations API
+        // Using the Google API client's credentials
+        const auth = netAppClient.auth;
+        // Make a direct API call using axios
+        const response = await axios.request({
+            url: `https://netapp.googleapis.com/v1/${operationName}`,
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${await auth.getAccessToken()}`,
+            },
+        });
+        const operation = response.data;
+        // Parse the operation data
+        const formattedResponse = parseOperationMetadata(operation);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Retrieved details for operation '${operationName}'\n${JSON.stringify(formattedResponse, null, 2)}`,
+                },
+            ],
+            structuredContent: formattedResponse,
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error getting operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error getting operation: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            structuredContent: {
+                error: error.message || 'Unknown error',
+            },
+        };
+    }
+};
+// Cancel Operation Handler
+export const cancelOperationHandler = async (args) => {
+    try {
+        const { operationName } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Access the auth client to make direct API calls
+        const auth = netAppClient.auth;
+        // First, get the current operation state
+        const getResponse = await axios.request({
+            url: `https://netapp.googleapis.com/v1/${operationName}`,
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${await auth.getAccessToken()}`,
+            },
+        });
+        const operation = getResponse.data;
+        // Check if operation is already completed
+        if (operation.done) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Operation '${operationName}' is already completed and cannot be cancelled.`,
+                    },
+                ],
+                structuredContent: {
+                    success: false,
+                    message: 'Operation already completed',
+                },
+            };
+        }
+        // Cancel the operation using direct API call
+        await axios.request({
+            url: `https://netapp.googleapis.com/v1/${operationName}:cancel`,
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${await auth.getAccessToken()}`,
+            },
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Successfully requested cancellation of operation '${operationName}'.`,
+                },
+            ],
+            structuredContent: {
+                success: true,
+                message: 'Cancellation request submitted successfully',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error cancelling operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error cancelling operation: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            structuredContent: {
+                success: false,
+                message: error.message || 'Unknown error',
+            },
+        };
+    }
+};
+// List Operations Handler
+export const listOperationsHandler = async (args) => {
+    try {
+        const { projectId, location, filter, pageSize, pageToken } = args;
+        // Create a new NetApp client using the factory
+        const netAppClient = NetAppClientFactory.createClient();
+        // Make a direct API call using the client's auth credentials
+        const auth = netAppClient.auth;
+        // Build the request parameters
+        const params = {};
+        if (filter)
+            params.filter = filter;
+        if (pageSize)
+            params.pageSize = pageSize;
+        if (pageToken)
+            params.pageToken = pageToken;
+        // Make the API request
+        const response = await axios.request({
+            url: `https://netapp.googleapis.com/v1/projects/${projectId}/locations/${location}/operations`,
+            method: 'GET',
+            params,
+            headers: {
+                Authorization: `Bearer ${await auth.getAccessToken()}`,
+            },
+        });
+        log.info({ responseData: response.data }, 'List operations response');
+        // Type assertion for response data
+        const responseData = response.data;
+        const operations = responseData.operations || [];
+        const nextPageToken = responseData.nextPageToken;
+        // Format the operations
+        const formattedOperations = operations.map((op) => {
+            const done = op.done === true;
+            const result = {
+                name: op.name || '',
+                done,
+                success: done,
+            };
+            // Extract metadata
+            if (op.metadata) {
+                if (op.metadata.createTime) {
+                    result.createTime = op.metadata.createTime;
+                }
+                if (op.metadata.target) {
+                    result.target = op.metadata.target;
+                }
+                if (op.metadata.verb) {
+                    result.verb = op.metadata.verb;
+                }
+                if (op.metadata.statusMessage) {
+                    result.statusMessage = op.metadata.statusMessage;
+                }
+            }
+            return result;
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ operations: response.data, nextPageToken: nextPageToken }, null, 2),
+                },
+            ],
+            structuredContent: {
+                operations: formattedOperations,
+                nextPageToken: nextPageToken,
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error listing operations');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error listing operations: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            structuredContent: {
+                operations: [],
+                error: error.message || 'Unknown error',
+            },
+        };
+    }
+};