@mcp-consultant-tools/azure-data-factory 27.0.0-beta.1

package/build/index.js

@@ -0,0 +1,911 @@
+#!/usr/bin/env node
+/**
+ * Azure Data Factory MCP Server
+ *
+ * Provides tools for pipeline execution, monitoring, and error debugging.
+ */
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { pathToFileURL } from 'node:url';
+import { realpathSync } from 'node:fs';
+import { createMcpServer, createEnvLoader } from '@mcp-consultant-tools/core';
+import { z } from 'zod';
+import { AdfService } from './AdfService.js';
+import { formatPipelineRunSummary, formatActivityRuns, formatPipelineList, formatTriggerList, formatIntegrationRuntimeStatus, formatPipelineRunsJson, formatActivityRunsJson, } from './utils/formatters.js';
+export function registerAzureDataFactoryTools(server, adfService) {
+    let service = adfService || null;
+    function getService() {
+        if (!service) {
+            const missingConfig = [];
+            let factories = [];
+            // Parse factory configuration
+            if (process.env.AZURE_DATA_FACTORIES) {
+                try {
+                    factories = JSON.parse(process.env.AZURE_DATA_FACTORIES);
+                }
+                catch (error) {
+                    throw new Error('Failed to parse AZURE_DATA_FACTORIES JSON');
+                }
+            }
+            else if (process.env.AZURE_DATA_FACTORY_SUBSCRIPTION_ID) {
+                // Single factory configuration
+                factories = [
+                    {
+                        id: 'default',
+                        name: 'Default Data Factory',
+                        subscriptionId: process.env.AZURE_DATA_FACTORY_SUBSCRIPTION_ID,
+                        resourceGroup: process.env.AZURE_DATA_FACTORY_RESOURCE_GROUP || '',
+                        factoryName: process.env.AZURE_DATA_FACTORY_NAME || '',
+                        active: true,
+                    },
+                ];
+                if (!factories[0].resourceGroup) {
+                    missingConfig.push('AZURE_DATA_FACTORY_RESOURCE_GROUP');
+                }
+                if (!factories[0].factoryName) {
+                    missingConfig.push('AZURE_DATA_FACTORY_NAME');
+                }
+            }
+            else {
+                missingConfig.push('AZURE_DATA_FACTORIES or AZURE_DATA_FACTORY_SUBSCRIPTION_ID');
+            }
+            // Check Azure AD credentials
+            if (!process.env.AZURE_TENANT_ID) {
+                missingConfig.push('AZURE_TENANT_ID');
+            }
+            if (!process.env.AZURE_CLIENT_ID) {
+                missingConfig.push('AZURE_CLIENT_ID');
+            }
+            if (!process.env.AZURE_CLIENT_SECRET) {
+                missingConfig.push('AZURE_CLIENT_SECRET');
+            }
+            if (missingConfig.length > 0) {
+                throw new Error(`Missing Azure Data Factory configuration: ${missingConfig.join(', ')}`);
+            }
+            const config = {
+                factories,
+                tenantId: process.env.AZURE_TENANT_ID,
+                clientId: process.env.AZURE_CLIENT_ID,
+                clientSecret: process.env.AZURE_CLIENT_SECRET,
+                enableWrite: process.env.AZURE_DATA_FACTORY_ENABLE_WRITE?.toLowerCase() === 'true',
+                enableTriggerControl: process.env.AZURE_DATA_FACTORY_ENABLE_TRIGGER_CONTROL?.toLowerCase() ===
+                    'true',
+            };
+            service = new AdfService(config);
+            console.error('Azure Data Factory service initialized');
+        }
+        return service;
+    }
+    // ========================================
+    // FACTORY TOOLS
+    // ========================================
+    server.tool('adf-list-factories', 'List all configured Azure Data Factory instances', {}, async () => {
+        try {
+            const svc = getService();
+            const factories = svc.getAllFactories();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            factories: factories.map((f) => ({
+                                id: f.id,
+                                name: f.name,
+                                factoryName: f.factoryName,
+                                resourceGroup: f.resourceGroup,
+                                active: f.active,
+                            })),
+                            writeEnabled: svc.isWriteEnabled(),
+                            triggerControlEnabled: svc.isTriggerControlEnabled(),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error listing factories:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to list factories: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // ========================================
+    // PIPELINE TOOLS
+    // ========================================
+    server.tool('adf-list-pipelines', 'List all pipelines in an Azure Data Factory', {
+        factoryId: z
+            .string()
+            .optional()
+            .describe('Factory ID (use adf-list-factories to find IDs)'),
+    }, async ({ factoryId }) => {
+        try {
+            const svc = getService();
+            const pipelines = await svc.listPipelines(factoryId);
+            const factory = svc.resolveFactory(factoryId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `## Pipelines in ${factory.name}\n\n` +
+                            formatPipelineList(pipelines) +
+                            `\n\n**Total: ${pipelines.length} pipelines**`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error listing pipelines:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to list pipelines: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-get-pipeline', 'Get details of a specific pipeline including activities and parameters', {
+        pipelineName: z.string().describe('Name of the pipeline'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ pipelineName, factoryId, }) => {
+        try {
+            const svc = getService();
+            const pipeline = await svc.getPipeline(pipelineName, factoryId);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(pipeline, null, 2) }],
+            };
+        }
+        catch (error) {
+            console.error('Error getting pipeline:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to get pipeline: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-run-pipeline', 'Trigger an Azure Data Factory pipeline run. Requires AZURE_DATA_FACTORY_ENABLE_WRITE=true.', {
+        pipelineName: z.string().describe('Name of the pipeline to run'),
+        parameters: z
+            .record(z.any())
+            .optional()
+            .describe('Pipeline parameters as key-value pairs'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ pipelineName, parameters, factoryId, }) => {
+        try {
+            const svc = getService();
+            const result = await svc.runPipeline(pipelineName, parameters, factoryId);
+            const factory = svc.resolveFactory(factoryId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            runId: result.runId,
+                            message: `Pipeline '${pipelineName}' triggered successfully`,
+                            factory: factory.name,
+                            monitorUrl: `https://adf.azure.com/en/monitoring/pipelineRuns/${result.runId}`,
+                            nextSteps: [
+                                `Use adf-get-pipeline-run with runId '${result.runId}' to check status`,
+                                "Use adf-get-activity-runs to see activity-level details if the run fails",
+                            ],
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error running pipeline:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to run pipeline: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-get-pipeline-run', 'Get the status and details of a pipeline run including error messages if failed', {
+        runId: z.string().describe('The pipeline run ID'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ runId, factoryId }) => {
+        try {
+            const svc = getService();
+            const run = await svc.getPipelineRun(runId, factoryId);
+            return {
+                content: [{ type: 'text', text: formatPipelineRunSummary(run) }],
+            };
+        }
+        catch (error) {
+            console.error('Error getting pipeline run:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to get pipeline run: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-get-activity-runs', 'Get activity-level details for a pipeline run. Essential for debugging - shows which activity failed and why.', {
+        runId: z.string().describe('The pipeline run ID'),
+        status: z
+            .enum(['Succeeded', 'Failed', 'InProgress', 'Cancelled', 'Queued'])
+            .optional()
+            .describe('Filter by activity status'),
+        activityName: z
+            .string()
+            .optional()
+            .describe('Filter by specific activity name'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ runId, status, activityName, factoryId, }) => {
+        try {
+            const svc = getService();
+            const activities = await svc.getActivityRuns(runId, factoryId, {
+                status,
+                activityName,
+            });
+            // Try to get pipeline run info for context
+            let pipelineRun;
+            try {
+                pipelineRun = await svc.getPipelineRun(runId, factoryId);
+            }
+            catch {
+                // Ignore - just for context
+            }
+            const formatted = formatActivityRuns(activities, pipelineRun);
+            const json = formatActivityRunsJson(activities);
+            return {
+                content: [
+                    { type: 'text', text: formatted },
+                    {
+                        type: 'text',
+                        text: '\n\n---\n\n**JSON Response:**\n\n```json\n' + JSON.stringify(json, null, 2) + '\n```',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error getting activity runs:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get activity runs: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-cancel-pipeline-run', 'Cancel a running pipeline. Requires AZURE_DATA_FACTORY_ENABLE_WRITE=true.', {
+        runId: z.string().describe('The pipeline run ID to cancel'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ runId, factoryId }) => {
+        try {
+            const svc = getService();
+            await svc.cancelPipelineRun(runId, factoryId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            message: `Pipeline run '${runId}' cancellation initiated`,
+                            note: 'The pipeline may take a moment to fully cancel',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error cancelling pipeline run:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to cancel pipeline run: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-query-pipeline-runs', 'Query pipeline runs with filters (date range, status, pipeline name)', {
+        lastDays: z
+            .number()
+            .optional()
+            .default(7)
+            .describe('Number of days to look back (default: 7)'),
+        pipelineName: z.string().optional().describe('Filter by pipeline name'),
+        status: z
+            .enum(['Queued', 'InProgress', 'Succeeded', 'Failed', 'Canceling', 'Cancelled'])
+            .optional()
+            .describe('Filter by run status'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ lastDays, pipelineName, status, factoryId, }) => {
+        try {
+            const svc = getService();
+            const now = new Date();
+            const days = lastDays || 7;
+            const request = {
+                lastUpdatedAfter: new Date(now.getTime() - days * 24 * 60 * 60 * 1000).toISOString(),
+                lastUpdatedBefore: new Date(now.getTime() + 24 * 60 * 60 * 1000).toISOString(),
+                filters: [],
+                orderBy: [{ orderBy: 'RunStart', order: 'DESC' }],
+            };
+            if (pipelineName) {
+                request.filters.push({
+                    operand: 'PipelineName',
+                    operator: 'Equals',
+                    values: [pipelineName],
+                });
+            }
+            if (status) {
+                request.filters.push({
+                    operand: 'Status',
+                    operator: 'Equals',
+                    values: [status],
+                });
+            }
+            const result = await svc.queryPipelineRuns(request, factoryId);
+            const formatted = formatPipelineRunsJson(result.value);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(formatted, null, 2) }],
+            };
+        }
+        catch (error) {
+            console.error('Error querying pipeline runs:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to query pipeline runs: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-rerun-pipeline', 'Rerun a failed pipeline from the point of failure (recovery mode). Requires AZURE_DATA_FACTORY_ENABLE_WRITE=true.', {
+        failedRunId: z.string().describe('The run ID of the failed pipeline'),
+        startFromFailure: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe('Start from failed activities (default: true)'),
+        startActivityName: z
+            .string()
+            .optional()
+            .describe('Optionally specify exact activity to start from'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ failedRunId, startFromFailure, startActivityName, factoryId, }) => {
+        try {
+            const svc = getService();
+            // Get the original run to find the pipeline name
+            const originalRun = await svc.getPipelineRun(failedRunId, factoryId);
+            const result = await svc.runPipeline(originalRun.pipelineName, originalRun.parameters, factoryId, {
+                referencePipelineRunId: failedRunId,
+                isRecovery: true,
+                startFromFailure: startFromFailure ?? true,
+                startActivityName,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            runId: result.runId,
+                            message: `Pipeline '${originalRun.pipelineName}' rerun initiated in recovery mode`,
+                            originalRunId: failedRunId,
+                            startFromFailure: startFromFailure ?? true,
+                            startActivityName: startActivityName || 'Auto-detect failed activities',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error rerunning pipeline:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to rerun pipeline: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // ========================================
+    // DATASET TOOLS
+    // ========================================
+    server.tool('adf-list-datasets', 'List all datasets in an Azure Data Factory', {
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ factoryId }) => {
+        try {
+            const svc = getService();
+            const datasets = await svc.listDatasets(factoryId);
+            const factory = svc.resolveFactory(factoryId);
+            const summary = datasets.map((d) => ({
+                name: d.name,
+                type: d.properties.type,
+                linkedService: d.properties.linkedServiceName?.referenceName,
+                folder: d.properties.folder?.name,
+            }));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            factory: factory.name,
+                            count: datasets.length,
+                            datasets: summary,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error listing datasets:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to list datasets: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-get-dataset', 'Get details of a specific dataset including schema', {
+        datasetName: z.string().describe('Name of the dataset'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ datasetName, factoryId, }) => {
+        try {
+            const svc = getService();
+            const dataset = await svc.getDataset(datasetName, factoryId);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(dataset, null, 2) }],
+            };
+        }
+        catch (error) {
+            console.error('Error getting dataset:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to get dataset: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // ========================================
+    // LINKED SERVICE TOOLS
+    // ========================================
+    server.tool('adf-list-linked-services', 'List all linked services in an Azure Data Factory (credentials sanitized for security)', {
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ factoryId }) => {
+        try {
+            const svc = getService();
+            const linkedServices = await svc.listLinkedServices(factoryId);
+            const factory = svc.resolveFactory(factoryId);
+            const summary = linkedServices.map((ls) => ({
+                name: ls.name,
+                type: ls.properties.type,
+                description: ls.properties.description,
+                connectVia: ls.properties.connectVia?.referenceName,
+            }));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            factory: factory.name,
+                            count: linkedServices.length,
+                            linkedServices: summary,
+                            note: 'Connection strings and credentials are redacted for security',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error listing linked services:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to list linked services: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // ========================================
+    // DATA FLOW TOOLS
+    // ========================================
+    server.tool('adf-list-data-flows', 'List all data flows in an Azure Data Factory', {
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ factoryId }) => {
+        try {
+            const svc = getService();
+            const dataFlows = await svc.listDataFlows(factoryId);
+            const factory = svc.resolveFactory(factoryId);
+            const summary = dataFlows.map((df) => ({
+                name: df.name,
+                type: df.properties.type,
+                description: df.properties.description,
+                folder: df.properties.folder?.name,
+            }));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            factory: factory.name,
+                            count: dataFlows.length,
+                            dataFlows: summary,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error listing data flows:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to list data flows: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-get-data-flow', 'Get details of a specific data flow', {
+        dataFlowName: z.string().describe('Name of the data flow'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ dataFlowName, factoryId, }) => {
+        try {
+            const svc = getService();
+            const dataFlow = await svc.getDataFlow(dataFlowName, factoryId);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(dataFlow, null, 2) }],
+            };
+        }
+        catch (error) {
+            console.error('Error getting data flow:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to get data flow: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // ========================================
+    // TRIGGER TOOLS
+    // ========================================
+    server.tool('adf-list-triggers', 'List all triggers in an Azure Data Factory with their current state', {
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ factoryId }) => {
+        try {
+            const svc = getService();
+            const triggers = await svc.listTriggers(factoryId);
+            const factory = svc.resolveFactory(factoryId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `## Triggers in ${factory.name}\n\n` +
+                            formatTriggerList(triggers) +
+                            `\n\n**Total: ${triggers.length} triggers**`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error listing triggers:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to list triggers: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-get-trigger', 'Get details of a specific trigger including its configuration', {
+        triggerName: z.string().describe('Name of the trigger'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ triggerName, factoryId, }) => {
+        try {
+            const svc = getService();
+            const trigger = await svc.getTrigger(triggerName, factoryId);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(trigger, null, 2) }],
+            };
+        }
+        catch (error) {
+            console.error('Error getting trigger:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to get trigger: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-start-trigger', 'Start (activate) a trigger. Requires AZURE_DATA_FACTORY_ENABLE_TRIGGER_CONTROL=true.', {
+        triggerName: z.string().describe('Name of the trigger to start'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ triggerName, factoryId, }) => {
+        try {
+            const svc = getService();
+            await svc.startTrigger(triggerName, factoryId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            message: `Trigger '${triggerName}' start initiated`,
+                            note: 'The trigger may take a moment to fully start',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error starting trigger:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to start trigger: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-stop-trigger', 'Stop (deactivate) a trigger. Requires AZURE_DATA_FACTORY_ENABLE_TRIGGER_CONTROL=true.', {
+        triggerName: z.string().describe('Name of the trigger to stop'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ triggerName, factoryId, }) => {
+        try {
+            const svc = getService();
+            await svc.stopTrigger(triggerName, factoryId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            message: `Trigger '${triggerName}' stop initiated`,
+                            note: 'The trigger may take a moment to fully stop',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error stopping trigger:', error);
+            return {
+                content: [
+                    { type: 'text', text: `Failed to stop trigger: ${error.message}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-query-trigger-runs', 'Query trigger execution history', {
+        lastDays: z
+            .number()
+            .optional()
+            .default(7)
+            .describe('Number of days to look back (default: 7)'),
+        triggerName: z.string().optional().describe('Filter by trigger name'),
+        status: z
+            .enum(['Succeeded', 'Failed', 'Inprogress'])
+            .optional()
+            .describe('Filter by run status'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ lastDays, triggerName, status, factoryId, }) => {
+        try {
+            const svc = getService();
+            const now = new Date();
+            const days = lastDays || 7;
+            const request = {
+                lastUpdatedAfter: new Date(now.getTime() - days * 24 * 60 * 60 * 1000).toISOString(),
+                lastUpdatedBefore: new Date(now.getTime() + 24 * 60 * 60 * 1000).toISOString(),
+                filters: [],
+                orderBy: [
+                    { orderBy: 'TriggerRunTimestamp', order: 'DESC' },
+                ],
+            };
+            if (triggerName) {
+                request.filters.push({
+                    operand: 'TriggerName',
+                    operator: 'Equals',
+                    values: [triggerName],
+                });
+            }
+            if (status) {
+                request.filters.push({
+                    operand: 'Status',
+                    operator: 'Equals',
+                    values: [status],
+                });
+            }
+            const result = await svc.queryTriggerRuns(request, factoryId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            count: result.value.length,
+                            triggerRuns: result.value.map((tr) => ({
+                                triggerRunId: tr.triggerRunId,
+                                triggerName: tr.triggerName,
+                                triggerType: tr.triggerType,
+                                status: tr.status,
+                                timestamp: tr.triggerRunTimestamp,
+                                message: tr.message,
+                            })),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error querying trigger runs:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to query trigger runs: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // ========================================
+    // INTEGRATION RUNTIME TOOLS
+    // ========================================
+    server.tool('adf-list-integration-runtimes', 'List all integration runtimes in an Azure Data Factory', {
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ factoryId }) => {
+        try {
+            const svc = getService();
+            const runtimes = await svc.listIntegrationRuntimes(factoryId);
+            const factory = svc.resolveFactory(factoryId);
+            const summary = runtimes.map((ir) => ({
+                name: ir.name,
+                type: ir.properties.type,
+                state: ir.properties.state,
+                description: ir.properties.description,
+            }));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            factory: factory.name,
+                            count: runtimes.length,
+                            integrationRuntimes: summary,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error listing integration runtimes:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to list integration runtimes: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-get-integration-runtime-status', 'Get detailed status of an integration runtime', {
+        irName: z.string().describe('Name of the integration runtime'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ irName, factoryId }) => {
+        try {
+            const svc = getService();
+            const status = await svc.getIntegrationRuntimeStatus(irName, factoryId);
+            return {
+                content: [{ type: 'text', text: formatIntegrationRuntimeStatus(status) }],
+            };
+        }
+        catch (error) {
+            console.error('Error getting integration runtime status:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get integration runtime status: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-start-integration-runtime', 'Start a managed integration runtime. Requires AZURE_DATA_FACTORY_ENABLE_WRITE=true.', {
+        irName: z.string().describe('Name of the integration runtime to start'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ irName, factoryId }) => {
+        try {
+            const svc = getService();
+            await svc.startIntegrationRuntime(irName, factoryId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            message: `Integration runtime '${irName}' start initiated`,
+                            note: 'Managed IR startup can take 2-5 minutes',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error starting integration runtime:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to start integration runtime: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('adf-stop-integration-runtime', 'Stop a managed integration runtime. Requires AZURE_DATA_FACTORY_ENABLE_WRITE=true.', {
+        irName: z.string().describe('Name of the integration runtime to stop'),
+        factoryId: z.string().optional().describe('Factory ID'),
+    }, async ({ irName, factoryId }) => {
+        try {
+            const svc = getService();
+            await svc.stopIntegrationRuntime(irName, factoryId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            message: `Integration runtime '${irName}' stop initiated`,
+                            note: 'The IR may take a moment to fully stop',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error stopping integration runtime:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to stop integration runtime: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    console.error('Azure Data Factory tools registered: 24 tools');
+}
+// CLI entry point (standalone execution)
+if (import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {
+    const loadEnv = createEnvLoader();
+    loadEnv();
+    const server = createMcpServer({
+        name: 'mcp-azure-data-factory',
+        version: '1.0.0',
+        capabilities: { tools: {} },
+    });
+    registerAzureDataFactoryTools(server);
+    const transport = new StdioServerTransport();
+    server.connect(transport).catch((error) => {
+        console.error('Failed to start Azure Data Factory MCP server:', error);
+        process.exit(1);
+    });
+    console.error('Azure Data Factory MCP server running');
+}
+//# sourceMappingURL=index.js.map