@houmak/minerva-mcp-server/dist/migration-tools.js

Minerva Model Context Protocol (MCP) Server for Microsoft 365 and Azure integrations

import { z } from "zod";
import { logger } from "./logger.js";
export function registerMigrationTools(server, powershellExecutor) {
    console.error("Registering SharePoint Migration tools...");
    // Migration de listes SharePoint
    server.tool("migrateSharePointList", "Migrate SharePoint list from source site to target site with data, schema and permissions", {
        sourceSiteUrl: z.string().describe("URL of the source SharePoint site"),
        targetSiteUrl: z.string().describe("URL of the target SharePoint site"),
        sourceList: z.string().describe("Name of the source list"),
        targetList: z.string().describe("Name of the target list (can be same as source)"),
        includeData: z.boolean().default(true).describe("Include list data in migration"),
        includeSchema: z.boolean().default(true).describe("Include list schema in migration"),
        includePermissions: z.boolean().default(true).describe("Include list permissions in migration"),
        overwriteExisting: z.boolean().default(false).describe("Overwrite existing list if it exists")
    }, async ({ sourceSiteUrl, targetSiteUrl, sourceList, targetList, includeData, includeSchema, includePermissions, overwriteExisting }) => {
        try {
            logger.info(`Starting SharePoint list migration: ${sourceList} -> ${targetList}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Migrate-SharePointLists.ps1",
                parameters: {
                    SourceSiteUrl: sourceSiteUrl,
                    TargetSiteUrl: targetSiteUrl,
                    SourceList: sourceList,
                    TargetList: targetList,
                    IncludeData: includeData,
                    IncludeSchema: includeSchema,
                    IncludePermissions: includePermissions,
                    OverwriteExisting: overwriteExisting
                }
            });
            if (result.success) {
                logger.info(`SharePoint list migration completed successfully`);
                return {
                    success: true,
                    message: `SharePoint list '${sourceList}' migrated successfully to '${targetList}'`,
                    details: result.data
                };
            }
            else {
                logger.error(`SharePoint list migration failed: ${result.error}`);
                return {
                    success: false,
                    error: `Migration failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during SharePoint list migration: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Migration de documents SharePoint
    server.tool("migrateSharePointDocuments", "Migrate SharePoint document library from source site to target site", {
        sourceSiteUrl: z.string().describe("URL of the source SharePoint site"),
        targetSiteUrl: z.string().describe("URL of the target SharePoint site"),
        sourceLibrary: z.string().describe("Name of the source document library"),
        targetLibrary: z.string().describe("Name of the target document library"),
        includePermissions: z.boolean().default(true).describe("Include library permissions in migration"),
        includeMetadata: z.boolean().default(true).describe("Include document metadata in migration"),
        overwriteExisting: z.boolean().default(false).describe("Overwrite existing documents if they exist")
    }, async ({ sourceSiteUrl, targetSiteUrl, sourceLibrary, targetLibrary, includePermissions, includeMetadata, overwriteExisting }) => {
        try {
            logger.info(`Starting SharePoint document migration: ${sourceLibrary} -> ${targetLibrary}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Migrate-SharePointDocuments.ps1",
                parameters: {
                    SourceSiteUrl: sourceSiteUrl,
                    TargetSiteUrl: targetSiteUrl,
                    SourceLibrary: sourceLibrary,
                    TargetLibrary: targetLibrary,
                    IncludePermissions: includePermissions,
                    IncludeMetadata: includeMetadata,
                    OverwriteExisting: overwriteExisting
                }
            });
            if (result.success) {
                logger.info(`SharePoint document migration completed successfully`);
                return {
                    success: true,
                    message: `SharePoint library '${sourceLibrary}' migrated successfully to '${targetLibrary}'`,
                    details: result.data
                };
            }
            else {
                logger.error(`SharePoint document migration failed: ${result.error}`);
                return {
                    success: false,
                    error: `Migration failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during SharePoint document migration: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Migration de content types SharePoint
    server.tool("migrateSharePointContentTypes", "Migrate SharePoint content types from source site to target site", {
        sourceSiteUrl: z.string().describe("URL of the source SharePoint site"),
        targetSiteUrl: z.string().describe("URL of the target SharePoint site"),
        contentTypeNames: z.array(z.string()).describe("Names of content types to migrate"),
        includeFields: z.boolean().default(true).describe("Include content type fields in migration"),
        includeWorkflows: z.boolean().default(false).describe("Include associated workflows in migration")
    }, async ({ sourceSiteUrl, targetSiteUrl, contentTypeNames, includeFields, includeWorkflows }) => {
        try {
            logger.info(`Starting SharePoint content type migration: ${contentTypeNames.join(', ')}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Migrate-SharePointContentTypes.ps1",
                parameters: {
                    SourceSiteUrl: sourceSiteUrl,
                    TargetSiteUrl: targetSiteUrl,
                    ContentTypeNames: contentTypeNames.join(','),
                    IncludeFields: includeFields,
                    IncludeWorkflows: includeWorkflows
                }
            });
            if (result.success) {
                logger.info(`SharePoint content type migration completed successfully`);
                return {
                    success: true,
                    message: `Content types migrated successfully: ${contentTypeNames.join(', ')}`,
                    details: result.data
                };
            }
            else {
                logger.error(`SharePoint content type migration failed: ${result.error}`);
                return {
                    success: false,
                    error: `Migration failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during SharePoint content type migration: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Migration de permissions SharePoint
    server.tool("migrateSharePointPermissions", "Migrate SharePoint permissions from source site to target site", {
        sourceSiteUrl: z.string().describe("URL of the source SharePoint site"),
        targetSiteUrl: z.string().describe("URL of the target SharePoint site"),
        includeInherited: z.boolean().default(true).describe("Include inherited permissions"),
        includeBroken: z.boolean().default(false).describe("Include broken permission references")
    }, async ({ sourceSiteUrl, targetSiteUrl, includeInherited, includeBroken }) => {
        try {
            logger.info(`Starting SharePoint permissions migration`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Migrate-SharePointPermissions.ps1",
                parameters: {
                    SourceSiteUrl: sourceSiteUrl,
                    TargetSiteUrl: targetSiteUrl,
                    IncludeInherited: includeInherited,
                    IncludeBroken: includeBroken
                }
            });
            if (result.success) {
                logger.info(`SharePoint permissions migration completed successfully`);
                return {
                    success: true,
                    message: `Permissions migrated successfully from ${sourceSiteUrl} to ${targetSiteUrl}`,
                    details: result.data
                };
            }
            else {
                logger.error(`SharePoint permissions migration failed: ${result.error}`);
                return {
                    success: false,
                    error: `Migration failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during SharePoint permissions migration: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Test des prérequis de migration
    server.tool("testMigrationPrerequisites", "Test prerequisites for SharePoint migration operations", {
        sourceSiteUrl: z.string().describe("URL of the source SharePoint site"),
        targetSiteUrl: z.string().describe("URL of the target SharePoint site"),
        migrationType: z.enum(["list", "document", "contenttype", "permissions"]).describe("Type of migration to test")
    }, async ({ sourceSiteUrl, targetSiteUrl, migrationType }) => {
        try {
            logger.info(`Testing migration prerequisites for ${migrationType}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Test-MigrationPrerequisites.ps1",
                parameters: {
                    SourceSiteUrl: sourceSiteUrl,
                    TargetSiteUrl: targetSiteUrl,
                    MigrationType: migrationType
                }
            });
            if (result.success) {
                logger.info(`Migration prerequisites test completed successfully`);
                return {
                    success: true,
                    message: `Prerequisites test passed for ${migrationType} migration`,
                    details: result.data
                };
            }
            else {
                logger.error(`Migration prerequisites test failed: ${result.error}`);
                return {
                    success: false,
                    error: `Prerequisites test failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during migration prerequisites test: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Statut de migration
    server.tool("getMigrationStatus", "Get status of SharePoint migration operations", {
        migrationId: z.string().describe("ID of the migration operation"),
        sourceSiteUrl: z.string().describe("URL of the source SharePoint site"),
        targetSiteUrl: z.string().describe("URL of the target SharePoint site")
    }, async ({ migrationId, sourceSiteUrl, targetSiteUrl }) => {
        try {
            logger.info(`Getting migration status for ${migrationId}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Get-MigrationStatus.ps1",
                parameters: {
                    MigrationId: migrationId,
                    SourceSiteUrl: sourceSiteUrl,
                    TargetSiteUrl: targetSiteUrl
                }
            });
            if (result.success) {
                logger.info(`Migration status retrieved successfully`);
                return {
                    success: true,
                    message: `Migration status retrieved for ${migrationId}`,
                    details: result.data
                };
            }
            else {
                logger.error(`Failed to get migration status: ${result.error}`);
                return {
                    success: false,
                    error: `Status retrieval failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error getting migration status: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
}