@houmak/minerva-mcp-server/dist/pnp-tools/index.js

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

import { z } from "zod";
import { logger } from "../logger.js";
import { dirname } from "path";
import { fileURLToPath } from "url";
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
export function registerAllPnPTools(server, powershellExecutor) {
    console.error("Registering All PnP PowerShell Sample tools...");
    // Note: migrateSharePointList is already registered in migration-tools.ts
    // This function now only registers PnP-specific tools
    // Site Inventory Tool
    server.tool("getSiteInventory", "Get complete inventory of SharePoint site including lists, libraries, and permissions", {
        siteUrl: z.string().describe("URL of the SharePoint site to inventory"),
        includeSubsites: z.boolean().default(true).describe("Include subsites in inventory"),
        includeLists: z.boolean().default(true).describe("Include lists and libraries in inventory"),
        includePermissions: z.boolean().default(false).describe("Include permission details in inventory"),
        outputPath: z.string().optional().describe("Path to save the inventory report (CSV format)")
    }, async ({ siteUrl, includeSubsites, includeLists, includePermissions, outputPath }) => {
        try {
            logger.info(`Starting SharePoint site inventory: ${siteUrl}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Get-SiteInventory.ps1",
                parameters: {
                    SiteUrl: siteUrl,
                    IncludeSubsites: includeSubsites,
                    IncludeLists: includeLists,
                    IncludePermissions: includePermissions,
                    OutputPath: outputPath || ""
                }
            });
            if (result.success) {
                logger.info(`SharePoint site inventory completed successfully`);
                return {
                    success: true,
                    message: `Site inventory completed for ${siteUrl}`,
                    details: result.data
                };
            }
            else {
                logger.error(`SharePoint site inventory failed: ${result.error}`);
                return {
                    success: false,
                    error: `Inventory failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during SharePoint site inventory: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Create SharePoint Site Tool
    server.tool("createSharePointSite", "Create a new SharePoint site with specified template and settings", {
        siteUrl: z.string().describe("URL of the new SharePoint site to create"),
        title: z.string().describe("Title of the new site"),
        description: z.string().optional().describe("Description of the new site"),
        template: z.string().default("STS#3").describe("Site template to use (e.g., STS#3 for Team Site)"),
        owner: z.string().describe("Owner of the new site"),
        timeZone: z.string().default("4").describe("Time zone ID for the site"),
        locale: z.string().default("1033").describe("Locale ID for the site")
    }, async ({ siteUrl, title, description, template, owner, timeZone, locale }) => {
        try {
            logger.info(`Creating SharePoint site: ${siteUrl}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "New-SharePointSite.ps1",
                parameters: {
                    SiteUrl: siteUrl,
                    Title: title,
                    Description: description || "",
                    Template: template,
                    Owner: owner,
                    TimeZone: timeZone,
                    Locale: locale
                }
            });
            if (result.success) {
                logger.info(`SharePoint site created successfully`);
                return {
                    success: true,
                    message: `SharePoint site created: ${siteUrl}`,
                    details: result.data
                };
            }
            else {
                logger.error(`SharePoint site creation failed: ${result.error}`);
                return {
                    success: false,
                    error: `Site creation failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during SharePoint site creation: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Get Teams Report Tool
    server.tool("getTeamsReport", "Generate comprehensive report of Microsoft Teams", {
        includeDetails: z.boolean().default(true).describe("Include detailed team information"),
        includeMembers: z.boolean().default(false).describe("Include team member details"),
        includeChannels: z.boolean().default(false).describe("Include channel information"),
        includeApps: z.boolean().default(false).describe("Include installed apps information"),
        outputPath: z.string().optional().describe("Path to save the report (CSV format)")
    }, async ({ includeDetails, includeMembers, includeChannels, includeApps, outputPath }) => {
        try {
            logger.info(`Generating Microsoft Teams report`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Get-TeamsReport.ps1",
                parameters: {
                    IncludeDetails: includeDetails,
                    IncludeMembers: includeMembers,
                    IncludeChannels: includeChannels,
                    IncludeApps: includeApps,
                    OutputPath: outputPath || ""
                }
            });
            if (result.success) {
                logger.info(`Teams report generated successfully`);
                return {
                    success: true,
                    message: `Teams report completed`,
                    details: result.data
                };
            }
            else {
                logger.error(`Teams report failed: ${result.error}`);
                return {
                    success: false,
                    error: `Teams report failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during Teams report generation: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Get AAD Users Report Tool
    server.tool("getAADUsersReport", "Generate comprehensive report of Azure Active Directory users", {
        includeDetails: z.boolean().default(true).describe("Include detailed user information"),
        includeGroups: z.boolean().default(false).describe("Include group membership details"),
        includeLicenses: z.boolean().default(false).describe("Include license information"),
        includeSignIns: z.boolean().default(false).describe("Include sign-in activity"),
        outputPath: z.string().optional().describe("Path to save the report (CSV format)")
    }, async ({ includeDetails, includeGroups, includeLicenses, includeSignIns, outputPath }) => {
        try {
            logger.info(`Generating AAD users report`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Get-AADUsersReport.ps1",
                parameters: {
                    IncludeDetails: includeDetails,
                    IncludeGroups: includeGroups,
                    IncludeLicenses: includeLicenses,
                    IncludeSignIns: includeSignIns,
                    OutputPath: outputPath || ""
                }
            });
            if (result.success) {
                logger.info(`AAD users report generated successfully`);
                return {
                    success: true,
                    message: `AAD users report completed`,
                    details: result.data
                };
            }
            else {
                logger.error(`AAD users report failed: ${result.error}`);
                return {
                    success: false,
                    error: `AAD users report failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during AAD users report generation: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Get Site Sharing Settings Tool
    server.tool("getSiteSharingSettings", "Get comprehensive sharing settings for SharePoint sites", {
        siteUrl: z.string().describe("URL of the SharePoint site"),
        outputPath: z.string().optional().describe("Path to save the sharing settings report")
    }, async ({ siteUrl, outputPath }) => {
        try {
            logger.info(`Getting site sharing settings: ${siteUrl}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Get-SiteSharingSettings.ps1",
                parameters: {
                    SiteUrl: siteUrl,
                    OutputPath: outputPath || ""
                }
            });
            if (result.success) {
                logger.info(`Site sharing settings retrieved successfully`);
                return {
                    success: true,
                    message: `Site sharing settings retrieved for ${siteUrl}`,
                    details: result.data
                };
            }
            else {
                logger.error(`Site sharing settings retrieval failed: ${result.error}`);
                return {
                    success: false,
                    error: `Sharing settings retrieval failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during site sharing settings retrieval: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Get Permission Audit Tool
    server.tool("getPermissionAudit", "Get comprehensive permission audit for SharePoint sites", {
        siteUrl: z.string().describe("URL of the SharePoint site"),
        includeListsItems: z.boolean().default(true).describe("Include list items with unique permissions"),
        excludeLimitedAccess: z.boolean().default(true).describe("Exclude limited access permissions"),
        outputPath: z.string().optional().describe("Path to save the permission audit report (CSV format)")
    }, async ({ siteUrl, includeListsItems, excludeLimitedAccess, outputPath }) => {
        try {
            logger.info(`Getting permission audit: ${siteUrl}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Get-PermissionAudit.ps1",
                parameters: {
                    SiteUrl: siteUrl,
                    IncludeListsItems: includeListsItems,
                    ExcludeLimitedAccess: excludeLimitedAccess,
                    OutputPath: outputPath || ""
                }
            });
            if (result.success) {
                logger.info(`Permission audit completed successfully`);
                return {
                    success: true,
                    message: `Permission audit completed for ${siteUrl}`,
                    details: result.data
                };
            }
            else {
                logger.error(`Permission audit failed: ${result.error}`);
                return {
                    success: false,
                    error: `Permission audit failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during permission audit: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Export Site Content Tool
    server.tool("exportSiteContent", "Export all content from a SharePoint site", {
        siteUrl: z.string().describe("URL of the SharePoint site to export"),
        exportFolder: z.string().describe("Local folder path to export content to"),
        packageName: z.string().default("SiteContent").describe("Name for the export package"),
        createPackage: z.boolean().default(true).describe("Create a ZIP package of the exported content"),
        includes: z.array(z.string()).optional().describe("Specific document libraries to include"),
        logFile: z.string().default("AUTO").describe("Log file name (AUTO for automatic naming)")
    }, async ({ siteUrl, exportFolder, packageName, createPackage, includes, logFile }) => {
        try {
            logger.info(`Starting site content export: ${siteUrl}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Export-SiteContent.ps1",
                parameters: {
                    SiteUrl: siteUrl,
                    ExportFolder: exportFolder,
                    PackageName: packageName,
                    CreatePackage: createPackage,
                    Includes: includes ? includes.join(',') : "",
                    LogFile: logFile
                }
            });
            if (result.success) {
                logger.info(`Site content export completed successfully`);
                return {
                    success: true,
                    message: `Site content export completed for ${siteUrl}`,
                    details: result.data
                };
            }
            else {
                logger.error(`Site content export failed: ${result.error}`);
                return {
                    success: false,
                    error: `Site content export failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during site content export: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Get List Formatting Tool
    server.tool("getListFormatting", "Get list formatting information from SharePoint lists", {
        siteUrl: z.string().describe("URL of the SharePoint site"),
        listTitle: z.string().optional().describe("Title of specific list to get formatting for"),
        includeAllLists: z.boolean().default(false).describe("Get formatting for all lists in the site"),
        outputPath: z.string().optional().describe("Path to save the formatting information")
    }, async ({ siteUrl, listTitle, includeAllLists, outputPath }) => {
        try {
            logger.info(`Getting list formatting: ${siteUrl}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Get-ListFormatting.ps1",
                parameters: {
                    SiteUrl: siteUrl,
                    ListTitle: listTitle || "",
                    IncludeAllLists: includeAllLists,
                    OutputPath: outputPath || ""
                }
            });
            if (result.success) {
                logger.info(`List formatting information retrieved successfully`);
                return {
                    success: true,
                    message: `List formatting information retrieved for ${siteUrl}`,
                    details: result.data
                };
            }
            else {
                logger.error(`List formatting retrieval failed: ${result.error}`);
                return {
                    success: false,
                    error: `List formatting retrieval failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during list formatting retrieval: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Get External Users Tool
    server.tool("getExternalUsers", "Get external users information from SharePoint sites", {
        siteUrl: z.string().describe("URL of the SharePoint site"),
        includeGroups: z.boolean().default(false).describe("Include external users in groups"),
        outputPath: z.string().optional().describe("Path to save the external users information")
    }, async ({ siteUrl, includeGroups, outputPath }) => {
        try {
            logger.info(`Getting external users: ${siteUrl}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Get-ExternalUsers.ps1",
                parameters: {
                    SiteUrl: siteUrl,
                    IncludeGroups: includeGroups,
                    OutputPath: outputPath || ""
                }
            });
            if (result.success) {
                logger.info(`External users information retrieved successfully`);
                return {
                    success: true,
                    message: `External users information retrieved for ${siteUrl}`,
                    details: result.data
                };
            }
            else {
                logger.error(`External users retrieval failed: ${result.error}`);
                return {
                    success: false,
                    error: `External users retrieval failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during external users retrieval: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Get Flow Runs Summary Tool
    server.tool("getFlowRunsSummary", "Get Power Automate flow runs summary for a specific date", {
        environment: z.string().optional().describe("Power Platform environment name"),
        date: z.string().optional().describe("Date to get runs for (YYYY-MM-DD format, defaults to today)"),
        includeDetails: z.boolean().default(false).describe("Include detailed run information"),
        outputPath: z.string().optional().describe("Path to save the flow runs summary")
    }, async ({ environment, date, includeDetails, outputPath }) => {
        try {
            logger.info(`Getting flow runs summary for date: ${date || 'today'}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Get-FlowRunsSummary.ps1",
                parameters: {
                    Environment: environment || "",
                    Date: date || "",
                    IncludeDetails: includeDetails,
                    OutputPath: outputPath || ""
                }
            });
            if (result.success) {
                logger.info(`Flow runs summary retrieved successfully`);
                return {
                    success: true,
                    message: `Flow runs summary retrieved for ${date || 'today'}`,
                    details: result.data
                };
            }
            else {
                logger.error(`Flow runs summary retrieval failed: ${result.error}`);
                return {
                    success: false,
                    error: `Flow runs summary retrieval failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during flow runs summary retrieval: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Apply Site Template Tool
    server.tool("applySiteTemplate", "Apply or extract SharePoint site templates", {
        siteUrl: z.string().describe("URL of the SharePoint site"),
        templatePath: z.string().optional().describe("Path to the site template file"),
        templateName: z.string().optional().describe("Name for the extracted template"),
        parameters: z.record(z.string()).optional().describe("Parameters for template application"),
        extractTemplate: z.boolean().default(false).describe("Extract template from existing site instead of applying"),
        outputPath: z.string().optional().describe("Path to save the template operation details")
    }, async ({ siteUrl, templatePath, templateName, parameters, extractTemplate, outputPath }) => {
        try {
            logger.info(`Processing site template: ${extractTemplate ? 'extract' : 'apply'}`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Apply-SiteTemplate.ps1",
                parameters: {
                    SiteUrl: siteUrl,
                    TemplatePath: templatePath || "",
                    TemplateName: templateName || "",
                    Parameters: parameters ? JSON.stringify(parameters) : "{}",
                    ExtractTemplate: extractTemplate,
                    OutputPath: outputPath || ""
                }
            });
            if (result.success) {
                logger.info(`Site template operation completed successfully`);
                return {
                    success: true,
                    message: `Site template ${extractTemplate ? 'extraction' : 'application'} completed for ${siteUrl}`,
                    details: result.data
                };
            }
            else {
                logger.error(`Site template operation failed: ${result.error}`);
                return {
                    success: false,
                    error: `Site template operation failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during site template operation: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
    // Get Azure Resources Tool
    server.tool("getAzureResources", "Get and manage Azure resources", {
        resourceGroupName: z.string().optional().describe("Specific resource group name to query"),
        subscriptionId: z.string().optional().describe("Azure subscription ID"),
        includeDetails: z.boolean().default(false).describe("Include detailed resource information"),
        deleteResources: z.boolean().default(false).describe("Delete the resource group (use with caution)"),
        outputPath: z.string().optional().describe("Path to save the Azure resources information")
    }, async ({ resourceGroupName, subscriptionId, includeDetails, deleteResources, outputPath }) => {
        try {
            logger.info(`Getting Azure resources information`);
            const result = await powershellExecutor.executeScript({
                scriptPath: "Get-AzureResources.ps1",
                parameters: {
                    ResourceGroupName: resourceGroupName || "",
                    SubscriptionId: subscriptionId || "",
                    IncludeDetails: includeDetails,
                    DeleteResources: deleteResources,
                    OutputPath: outputPath || ""
                }
            });
            if (result.success) {
                logger.info(`Azure resources information retrieved successfully`);
                return {
                    success: true,
                    message: `Azure resources information retrieved successfully`,
                    details: result.data
                };
            }
            else {
                logger.error(`Azure resources retrieval failed: ${result.error}`);
                return {
                    success: false,
                    error: `Azure resources retrieval failed: ${result.error}`,
                    details: result.stderr
                };
            }
        }
        catch (error) {
            logger.error(`Error during Azure resources retrieval: ${error}`);
            return {
                success: false,
                error: `Unexpected error: ${error}`
            };
        }
    });
}