@gcnv/gcnv-mcp-server 1.0.3

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

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+// Create Backup Vault Tool
+export const createBackupVaultTool = {
+    name: 'gcnv_backup_vault_create',
+    title: 'Create Backup Vault',
+    description: 'Creates a new backup vault 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 vault should be created'),
+        backupVaultId: z.string().describe('The ID to assign to the backup vault'),
+        description: z.string().optional().describe('Optional description of the backup vault'),
+        labels: z
+            .record(z.string())
+            .optional()
+            .describe('Optional labels to apply to the backup vault'),
+    },
+    outputSchema: {
+        name: z.string().describe('The name of the created backup vault'),
+        operationId: z
+            .string()
+            .describe('The ID of the long-running operation for creating the backup vault'),
+    },
+};
+// Delete Backup Vault Tool
+export const deleteBackupVaultTool = {
+    name: 'gcnv_backup_vault_delete',
+    title: 'Delete Backup Vault',
+    description: 'Deletes a backup vault 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 vault'),
+        backupVaultId: z.string().describe('The ID of the backup vault to delete'),
+        force: z.boolean().optional().describe('Force deletion even if the vault contains backups'),
+    },
+    outputSchema: {
+        success: z.boolean().describe('Whether the deletion was successful'),
+        operationId: z.string().optional().describe('The ID of the long-running operation'),
+    },
+};
+// Get Backup Vault Tool
+export const getBackupVaultTool = {
+    name: 'gcnv_backup_vault_get',
+    title: 'Get Backup Vault',
+    description: 'Gets details of a specific backup vault',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the backup vault'),
+        backupVaultId: z.string().describe('The ID of the backup vault to retrieve'),
+    },
+    outputSchema: {
+        name: z.string().describe('The fully qualified name of the backup vault'),
+        backupVaultId: z.string().describe('The ID of the backup vault to retrieve'),
+        backupVaultType: z.string().describe('The type of the backup vault'),
+        sourceRegion: z.string().optional().describe('The source region of the backup vault'),
+        backupRegion: z.string().optional().describe('The backup region of the backup vault'),
+        sourceBackupVault: z
+            .string()
+            .optional()
+            .describe('The source backup vault for cross-region backups'),
+        destinationBackupVault: z
+            .string()
+            .optional()
+            .describe('The destination backup vault for cross-region backups'),
+        backupRetentionPolicy: z
+            .object({
+            backupMinimumEnforcedRetentionDays: z
+                .number()
+                .describe('The minimum enforced retention days for backups'),
+            dailyBackupImmutable: z.boolean().describe('Whether daily backups are immutable'),
+            weeklyBackupImmutable: z.boolean().describe('Whether weekly backups are immutable'),
+            monthlyBackupImmutable: z.boolean().describe('Whether monthly backups are immutable'),
+            manualBackupImmutable: z.boolean().describe('Whether manual backups are immutable'),
+        })
+            .optional()
+            .describe('The backup retention policy of the backup vault'),
+        state: z.string().describe('The current state of the backup vault'),
+        createTime: z.date().describe('The creation time of the backup vault'),
+        description: z.string().optional().describe('Description of the backup vault'),
+        labels: z.record(z.string()).optional().describe('Labels applied to the backup vault'),
+    },
+};
+// List Backup Vaults Tool
+export const listBackupVaultsTool = {
+    name: 'gcnv_backup_vault_list',
+    title: 'List Backup Vaults',
+    description: 'Lists backup vaults 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 vaults from'),
+        filter: z.string().optional().describe('Filter expression for filtering results'),
+        pageSize: z.number().optional().describe('Maximum number of backup vaults to return per page'),
+        pageToken: z.string().optional().describe('Page token from a previous list request'),
+    },
+    outputSchema: {
+        backupVaults: z
+            .array(z.object({
+            name: z.string().describe('The fully qualified name of the backup vault'),
+            backupVaultId: z.string().describe('The ID of the backup vault to retrieve'),
+            backupVaultType: z.string().describe('The type of the backup vault'),
+            sourceRegion: z.string().optional().describe('The source region of the backup vault'),
+            backupRegion: z.string().optional().describe('The backup region of the backup vault'),
+            sourceBackupVault: z
+                .string()
+                .optional()
+                .describe('The source backup vault for cross-region backups'),
+            destinationBackupVault: z
+                .string()
+                .optional()
+                .describe('The destination backup vault for cross-region backups'),
+            backupRetentionPolicy: z
+                .object({
+                backupMinimumEnforcedRetentionDays: z
+                    .number()
+                    .describe('The minimum enforced retention days for backups'),
+                dailyBackupImmutable: z.boolean().describe('Whether daily backups are immutable'),
+                weeklyBackupImmutable: z.boolean().describe('Whether weekly backups are immutable'),
+                monthlyBackupImmutable: z.boolean().describe('Whether monthly backups are immutable'),
+                manualBackupImmutable: z.boolean().describe('Whether manual backups are immutable'),
+            })
+                .optional()
+                .describe('The backup retention policy of the backup vault'),
+            state: z.string().describe('The current state of the backup vault'),
+            createTime: z.date().describe('The creation time of the backup vault'),
+            description: z.string().optional().describe('Description of the backup vault'),
+            labels: z.record(z.string()).optional().describe('Labels applied to the backup vault'),
+        }))
+            .describe('List of backup vaults'),
+        nextPageToken: z.string().optional().describe('Token for fetching the next page'),
+    },
+};
+// Update Backup Vault Tool
+export const updateBackupVaultTool = {
+    name: 'gcnv_backup_vault_update',
+    title: 'Update Backup Vault',
+    description: 'Updates the properties of an existing backup vault',
+    inputSchema: {
+        projectId: z.string().describe('The ID of the Google Cloud project'),
+        location: z.string().describe('The location of the backup vault'),
+        backupVaultId: z.string().describe('The ID of the backup vault to update'),
+        description: z.string().optional().describe('New description for the backup vault'),
+        labels: z.record(z.string()).optional().describe('New labels to apply to the backup vault'),
+    },
+    outputSchema: {
+        name: z.string().describe('The fully qualified name of the updated backup vault'),
+        operationId: z.string().describe('The ID of the long-running operation'),
+    },
+};

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

@@ -0,0 +1,321 @@
+import { NetAppClientFactory } from '../../utils/netapp-client-factory.js';
+import { logger } from '../../logger.js';
+const log = logger.child({ module: 'active-directory-handler' });
+// Helper to format active directory data
+function formatActiveDirectoryData(ad) {
+    const result = {};
+    if (!ad)
+        return result;
+    if (ad.name) {
+        const nameParts = ad.name.split('/');
+        result.name = ad.name;
+        result.activeDirectoryId = nameParts[nameParts.length - 1];
+    }
+    if (ad.domain)
+        result.domain = ad.domain;
+    if (ad.site)
+        result.site = ad.site;
+    if (ad.dns)
+        result.dns = ad.dns;
+    if (ad.netBiosPrefix)
+        result.netBiosPrefix = ad.netBiosPrefix;
+    if (ad.organizationalUnit)
+        result.organizationalUnit = ad.organizationalUnit;
+    if (ad.aesEncryption !== undefined)
+        result.aesEncryption = ad.aesEncryption;
+    if (ad.state)
+        result.state = ad.state;
+    if (ad.createTime) {
+        result.createTime = new Date(ad.createTime.seconds * 1000);
+    }
+    if (ad.description)
+        result.description = ad.description;
+    if (ad.labels)
+        result.labels = ad.labels;
+    return result;
+}
+// Create Active Directory Handler
+export const createActiveDirectoryHandler = async (args) => {
+    try {
+        const { projectId, location, activeDirectoryId, domain, site, dns, netBiosPrefix, organizationalUnit, aesEncryption, username, password, backupOperators, securityOperators, kdcHostname, kdcIp, nfsUsersWithLdap, description, labels, } = args;
+        const netAppClient = NetAppClientFactory.createClient();
+        const parent = `projects/${projectId}/locations/${location}`;
+        const activeDirectory = {};
+        if (domain)
+            activeDirectory.domain = domain;
+        if (site)
+            activeDirectory.site = site;
+        if (dns)
+            activeDirectory.dns = dns;
+        if (netBiosPrefix)
+            activeDirectory.netBiosPrefix = netBiosPrefix;
+        if (organizationalUnit)
+            activeDirectory.organizationalUnit = organizationalUnit;
+        if (aesEncryption !== undefined)
+            activeDirectory.aesEncryption = aesEncryption;
+        if (username)
+            activeDirectory.username = username;
+        if (password)
+            activeDirectory.password = password;
+        if (backupOperators)
+            activeDirectory.backupOperators = backupOperators;
+        if (securityOperators)
+            activeDirectory.securityOperators = securityOperators;
+        if (kdcHostname)
+            activeDirectory.kdcHostname = kdcHostname;
+        if (kdcIp)
+            activeDirectory.kdcIp = kdcIp;
+        if (nfsUsersWithLdap !== undefined)
+            activeDirectory.nfsUsersWithLdap = nfsUsersWithLdap;
+        if (description)
+            activeDirectory.description = description;
+        if (labels)
+            activeDirectory.labels = labels;
+        const request = {
+            parent,
+            activeDirectoryId,
+            activeDirectory,
+        };
+        log.info({ request }, 'Create Active Directory request');
+        const [operation] = await netAppClient.createActiveDirectory(request);
+        log.info({ operation }, 'Create Active Directory operation');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        name: `projects/${projectId}/locations/${location}/activeDirectories/${activeDirectoryId}`,
+                        operation: operation,
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                name: `projects/${projectId}/locations/${location}/activeDirectories/${activeDirectoryId}`,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error creating active directory');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error creating active directory: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Delete Active Directory Handler
+export const deleteActiveDirectoryHandler = async (args) => {
+    try {
+        const { projectId, location, activeDirectoryId } = args;
+        const netAppClient = NetAppClientFactory.createClient();
+        const name = `projects/${projectId}/locations/${location}/activeDirectories/${activeDirectoryId}`;
+        const [operation] = await netAppClient.deleteActiveDirectory({ name });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        message: `Active directory ${activeDirectoryId} deletion requested`,
+                        operation: operation,
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                success: true,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error deleting active directory');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error deleting active directory: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Get Active Directory Handler
+export const getActiveDirectoryHandler = async (args) => {
+    try {
+        const { projectId, location, activeDirectoryId } = args;
+        const netAppClient = NetAppClientFactory.createClient();
+        const name = `projects/${projectId}/locations/${location}/activeDirectories/${activeDirectoryId}`;
+        const [activeDirectory] = await netAppClient.getActiveDirectory({ name });
+        const formatted = formatActiveDirectoryData(activeDirectory);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(formatted, null, 2),
+                },
+            ],
+            structuredContent: formatted,
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error getting active directory');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error getting active directory: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// List Active Directories Handler
+export const listActiveDirectoriesHandler = async (args) => {
+    try {
+        const { projectId, location, filter, pageSize, pageToken } = 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;
+        const [activeDirectories, , response] = await netAppClient.listActiveDirectories(request);
+        const formatted = activeDirectories.map(formatActiveDirectoryData);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ activeDirectories, nextPageToken: response?.nextPageToken }, null, 2),
+                },
+            ],
+            structuredContent: {
+                activeDirectories: formatted,
+                nextPageToken: response?.nextPageToken,
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error listing active directories');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error listing active directories: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+// Update Active Directory Handler
+export const updateActiveDirectoryHandler = async (args) => {
+    try {
+        const { projectId, location, activeDirectoryId, domain, site, dns, netBiosPrefix, organizationalUnit, aesEncryption, username, password, backupOperators, securityOperators, kdcHostname, kdcIp, nfsUsersWithLdap, description, labels, } = args;
+        const netAppClient = NetAppClientFactory.createClient();
+        const name = `projects/${projectId}/locations/${location}/activeDirectories/${activeDirectoryId}`;
+        const updateMask = [];
+        const activeDirectory = { name };
+        if (domain !== undefined) {
+            activeDirectory.domain = domain;
+            updateMask.push('domain');
+        }
+        if (site !== undefined) {
+            activeDirectory.site = site;
+            updateMask.push('site');
+        }
+        if (dns !== undefined) {
+            activeDirectory.dns = dns;
+            updateMask.push('dns');
+        }
+        if (netBiosPrefix !== undefined) {
+            activeDirectory.netBiosPrefix = netBiosPrefix;
+            updateMask.push('net_bios_prefix');
+        }
+        if (organizationalUnit !== undefined) {
+            activeDirectory.organizationalUnit = organizationalUnit;
+            updateMask.push('organizational_unit');
+        }
+        if (aesEncryption !== undefined) {
+            activeDirectory.aesEncryption = aesEncryption;
+            updateMask.push('aes_encryption');
+        }
+        if (username !== undefined) {
+            activeDirectory.username = username;
+            updateMask.push('username');
+        }
+        if (password !== undefined) {
+            activeDirectory.password = password;
+            updateMask.push('password');
+        }
+        if (backupOperators !== undefined) {
+            activeDirectory.backupOperators = backupOperators;
+            updateMask.push('backup_operators');
+        }
+        if (securityOperators !== undefined) {
+            activeDirectory.securityOperators = securityOperators;
+            updateMask.push('security_operators');
+        }
+        if (kdcHostname !== undefined) {
+            activeDirectory.kdcHostname = kdcHostname;
+            updateMask.push('kdc_hostname');
+        }
+        if (kdcIp !== undefined) {
+            activeDirectory.kdcIp = kdcIp;
+            updateMask.push('kdc_ip');
+        }
+        if (nfsUsersWithLdap !== undefined) {
+            activeDirectory.nfsUsersWithLdap = nfsUsersWithLdap;
+            updateMask.push('nfs_users_with_ldap');
+        }
+        if (description !== undefined) {
+            activeDirectory.description = description;
+            updateMask.push('description');
+        }
+        if (labels !== undefined) {
+            activeDirectory.labels = labels;
+            updateMask.push('labels');
+        }
+        const request = {
+            activeDirectory,
+            updateMask: { paths: updateMask },
+        };
+        log.info({ request }, 'Update Active Directory request');
+        const [operation] = await netAppClient.updateActiveDirectory(request);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        message: `Active directory ${activeDirectoryId} update requested`,
+                        operation: operation,
+                    }, null, 2),
+                },
+            ],
+            structuredContent: {
+                name: name,
+                operationId: operation.name || '',
+            },
+        };
+    }
+    catch (error) {
+        log.error({ err: error }, 'Error updating active directory');
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error updating active directory: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};