@elad-nofy/mssql-mcp 1.0.0

package/dist/tools/jobs.js

@@ -0,0 +1,161 @@
+import { z } from 'zod';
+export const jobTools = {
+    list_jobs: {
+        description: 'List all SQL Server Agent jobs with their status and schedule',
+        inputSchema: z.object({
+            enabledOnly: z.boolean().optional().default(false).describe('Only show enabled jobs'),
+        }),
+        handler: async (client, args) => {
+            const enabledFilter = args.enabledOnly ? 'AND j.enabled = 1' : '';
+            const query = `
+        SELECT
+          j.job_id,
+          j.name as job_name,
+          j.description,
+          CASE j.enabled WHEN 1 THEN 'Enabled' ELSE 'Disabled' END as status,
+          c.name as category,
+          SUSER_SNAME(j.owner_sid) as owner,
+          j.date_created,
+          j.date_modified,
+          CASE
+            WHEN ja.run_requested_date IS NOT NULL AND ja.stop_execution_date IS NULL THEN 'Running'
+            ELSE 'Idle'
+          END as current_status,
+          h.last_run_date,
+          h.last_run_time,
+          h.last_run_outcome,
+          h.last_run_duration_seconds
+        FROM msdb.dbo.sysjobs j
+        LEFT JOIN msdb.dbo.syscategories c ON j.category_id = c.category_id
+        LEFT JOIN msdb.dbo.sysjobactivity ja ON j.job_id = ja.job_id
+          AND ja.session_id = (SELECT MAX(session_id) FROM msdb.dbo.sysjobactivity)
+        LEFT JOIN (
+          SELECT
+            job_id,
+            MAX(CAST(
+              CAST(run_date AS VARCHAR) + ' ' +
+              STUFF(STUFF(RIGHT('000000' + CAST(run_time AS VARCHAR), 6), 5, 0, ':'), 3, 0, ':')
+            AS DATETIME)) as last_run_date,
+            MAX(run_time) as last_run_time,
+            (SELECT TOP 1 CASE run_status
+              WHEN 0 THEN 'Failed'
+              WHEN 1 THEN 'Succeeded'
+              WHEN 2 THEN 'Retry'
+              WHEN 3 THEN 'Canceled'
+              WHEN 4 THEN 'In Progress'
+            END FROM msdb.dbo.sysjobhistory h2
+            WHERE h2.job_id = h.job_id AND h2.step_id = 0
+            ORDER BY run_date DESC, run_time DESC) as last_run_outcome,
+            (SELECT TOP 1
+              ((run_duration / 10000) * 3600) +
+              (((run_duration % 10000) / 100) * 60) +
+              (run_duration % 100)
+            FROM msdb.dbo.sysjobhistory h2
+            WHERE h2.job_id = h.job_id AND h2.step_id = 0
+            ORDER BY run_date DESC, run_time DESC) as last_run_duration_seconds
+          FROM msdb.dbo.sysjobhistory h
+          WHERE step_id = 0
+          GROUP BY job_id
+        ) h ON j.job_id = h.job_id
+        WHERE 1=1
+        ${enabledFilter}
+        ORDER BY j.name
+      `;
+            return await client.query(query);
+        },
+    },
+    get_running_jobs: {
+        description: 'Get currently executing SQL Server Agent jobs',
+        inputSchema: z.object({}),
+        handler: async (client) => {
+            const query = `
+        SELECT
+          j.name as job_name,
+          j.job_id,
+          ja.start_execution_date,
+          DATEDIFF(SECOND, ja.start_execution_date, GETDATE()) as running_seconds,
+          ISNULL(ja.last_executed_step_id, 0) as current_step,
+          js.step_name as current_step_name,
+          js.subsystem,
+          js.command as step_command
+        FROM msdb.dbo.sysjobactivity ja
+        INNER JOIN msdb.dbo.sysjobs j ON ja.job_id = j.job_id
+        LEFT JOIN msdb.dbo.sysjobsteps js ON j.job_id = js.job_id
+          AND ja.last_executed_step_id + 1 = js.step_id
+        WHERE ja.session_id = (SELECT MAX(session_id) FROM msdb.dbo.syssessions)
+        AND ja.start_execution_date IS NOT NULL
+        AND ja.stop_execution_date IS NULL
+        ORDER BY ja.start_execution_date
+      `;
+            return await client.query(query);
+        },
+    },
+    get_failed_jobs: {
+        description: 'Get jobs that failed in their last execution or recent history',
+        inputSchema: z.object({
+            hours: z.number().optional().default(24).describe('Look back this many hours for failures'),
+        }),
+        handler: async (client, args) => {
+            const query = `
+        SELECT
+          j.name as job_name,
+          j.job_id,
+          h.step_id,
+          h.step_name,
+          CAST(
+            CAST(h.run_date AS VARCHAR) + ' ' +
+            STUFF(STUFF(RIGHT('000000' + CAST(h.run_time AS VARCHAR), 6), 5, 0, ':'), 3, 0, ':')
+          AS DATETIME) as run_datetime,
+          ((h.run_duration / 10000) * 3600) +
+          (((h.run_duration % 10000) / 100) * 60) +
+          (h.run_duration % 100) as duration_seconds,
+          h.message as error_message
+        FROM msdb.dbo.sysjobhistory h
+        INNER JOIN msdb.dbo.sysjobs j ON h.job_id = j.job_id
+        WHERE h.run_status = 0  -- Failed
+        AND CAST(
+          CAST(h.run_date AS VARCHAR) + ' ' +
+          STUFF(STUFF(RIGHT('000000' + CAST(h.run_time AS VARCHAR), 6), 5, 0, ':'), 3, 0, ':')
+        AS DATETIME) > DATEADD(HOUR, -${args.hours || 24}, GETDATE())
+        ORDER BY h.run_date DESC, h.run_time DESC
+      `;
+            return await client.query(query);
+        },
+    },
+    get_job_history: {
+        description: 'Get execution history for a specific job',
+        inputSchema: z.object({
+            jobName: z.string().describe('Name of the job'),
+            top: z.number().optional().default(50).describe('Number of history records to return'),
+        }),
+        handler: async (client, args) => {
+            const query = `
+        SELECT TOP ${args.top || 50}
+          j.name as job_name,
+          h.step_id,
+          h.step_name,
+          CASE h.run_status
+            WHEN 0 THEN 'Failed'
+            WHEN 1 THEN 'Succeeded'
+            WHEN 2 THEN 'Retry'
+            WHEN 3 THEN 'Canceled'
+            WHEN 4 THEN 'In Progress'
+          END as status,
+          CAST(
+            CAST(h.run_date AS VARCHAR) + ' ' +
+            STUFF(STUFF(RIGHT('000000' + CAST(h.run_time AS VARCHAR), 6), 5, 0, ':'), 3, 0, ':')
+          AS DATETIME) as run_datetime,
+          ((h.run_duration / 10000) * 3600) +
+          (((h.run_duration % 10000) / 100) * 60) +
+          (h.run_duration % 100) as duration_seconds,
+          h.message
+        FROM msdb.dbo.sysjobhistory h
+        INNER JOIN msdb.dbo.sysjobs j ON h.job_id = j.job_id
+        WHERE j.name = @jobName
+        ORDER BY h.run_date DESC, h.run_time DESC, h.step_id
+      `;
+            return await client.query(query, { jobName: args.jobName });
+        },
+    },
+};
+//# sourceMappingURL=jobs.js.map

package/dist/tools/jobs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jobs.js","sourceRoot":"","sources":["../../src/tools/jobs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,SAAS,EAAE;QACT,WAAW,EAAE,+DAA+D;QAC5E,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC;YACpB,WAAW,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,wBAAwB,CAAC;SACtF,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,MAAmB,EAAE,IAA+B,EAAE,EAAE;YACtE,MAAM,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,CAAC;YAElE,MAAM,KAAK,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmDV,aAAa;;OAEhB,CAAC;YAEF,OAAO,MAAM,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC;KACF;IAED,gBAAgB,EAAE;QAChB,WAAW,EAAE,+CAA+C;QAC5D,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC;QACzB,OAAO,EAAE,KAAK,EAAE,MAAmB,EAAE,EAAE;YACrC,MAAM,KAAK,GAAG;;;;;;;;;;;;;;;;;;OAkBb,CAAC;YAEF,OAAO,MAAM,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC;KACF;IAED,eAAe,EAAE;QACf,WAAW,EAAE,gEAAgE;QAC7E,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC;YACpB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,wCAAwC,CAAC;SAC5F,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,MAAmB,EAAE,IAAwB,EAAE,EAAE;YAC/D,MAAM,KAAK,GAAG;;;;;;;;;;;;;;;;;;;;wCAoBoB,IAAI,CAAC,KAAK,IAAI,EAAE;;OAEjD,CAAC;YAEF,OAAO,MAAM,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC;KACF;IAED,eAAe,EAAE;QACf,WAAW,EAAE,0CAA0C;QACvD,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC;YACpB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,iBAAiB,CAAC;YAC/C,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,qCAAqC,CAAC;SACvF,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,MAAmB,EAAE,IAAuC,EAAE,EAAE;YAC9E,MAAM,KAAK,GAAG;qBACC,IAAI,CAAC,GAAG,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;OAuB5B,CAAC;YAEF,OAAO,MAAM,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;QAC9D,CAAC;KACF;CACF,CAAC"}

package/dist/tools/performance.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { MssqlClient } from '../mssqlClient.js';
+export declare const performanceTools: {
+    get_blocking: {
+        description: string;
+        inputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        handler: (client: MssqlClient) => Promise<{
+            blockingCount: number;
+            chains: import("mssql").IRecordSet<unknown>[];
+        }>;
+    };
+    get_wait_stats: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            top: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            excludeIdle: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            top: number;
+            excludeIdle: boolean;
+        }, {
+            top?: number | undefined;
+            excludeIdle?: boolean | undefined;
+        }>;
+        handler: (client: MssqlClient, args: {
+            top?: number;
+            excludeIdle?: boolean;
+        }) => Promise<import("mssql").IRecordSet<unknown>[]>;
+    };
+    get_cpu_usage: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            minutes: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            minutes: number;
+        }, {
+            minutes?: number | undefined;
+        }>;
+        handler: (client: MssqlClient, args: {
+            minutes?: number;
+        }) => Promise<import("mssql").IRecordSet<unknown>[]>;
+    };
+    get_index_usage: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            database: z.ZodString;
+            showUnused: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            database: string;
+            showUnused: boolean;
+        }, {
+            database: string;
+            showUnused?: boolean | undefined;
+        }>;
+        handler: (client: MssqlClient, args: {
+            database: string;
+            showUnused?: boolean;
+        }) => Promise<import("mssql").IRecordSet<unknown>[]>;
+    };
+};
+//# sourceMappingURL=performance.d.ts.map

package/dist/tools/performance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.d.ts","sourceRoot":"","sources":["../../src/tools/performance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,eAAO,MAAM,gBAAgB;;;;0BAID,WAAW;;;;;;;;;;;;;;;;;0BAoDX,WAAW,QAAQ;YAAE,GAAG,CAAC,EAAE,MAAM,CAAC;YAAC,WAAW,CAAC,EAAE,OAAO,CAAA;SAAE;;;;;;;;;;;0BA2C1D,WAAW,QAAQ;YAAE,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE;;;;;;;;;;;;;;0BAmCvC,WAAW,QAAQ;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,UAAU,CAAC,EAAE,OAAO,CAAA;SAAE;;CAkCxF,CAAC"}

package/dist/tools/performance.js

@@ -0,0 +1,162 @@
+import { z } from 'zod';
+export const performanceTools = {
+    get_blocking: {
+        description: 'Get current blocking chains showing blocked and blocking sessions',
+        inputSchema: z.object({}),
+        handler: async (client) => {
+            const query = `
+        WITH BlockingTree AS (
+          SELECT
+            r.session_id as blocked_session_id,
+            r.blocking_session_id,
+            s.login_name as blocked_login,
+            s.host_name as blocked_host,
+            s.program_name as blocked_program,
+            DB_NAME(r.database_id) as database_name,
+            r.wait_type,
+            r.wait_time / 1000.0 as wait_time_seconds,
+            r.wait_resource,
+            SUBSTRING(st.text, (r.statement_start_offset/2)+1,
+              ((CASE r.statement_end_offset
+                WHEN -1 THEN DATALENGTH(st.text)
+                ELSE r.statement_end_offset
+              END - r.statement_start_offset)/2)+1) as blocked_query
+          FROM sys.dm_exec_requests r
+          INNER JOIN sys.dm_exec_sessions s ON r.session_id = s.session_id
+          CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) st
+          WHERE r.blocking_session_id > 0
+        )
+        SELECT
+          bt.*,
+          bs.login_name as blocking_login,
+          bs.host_name as blocking_host,
+          bs.program_name as blocking_program,
+          COALESCE(
+            (SELECT TOP 1 text FROM sys.dm_exec_sql_text(bc.most_recent_sql_handle)),
+            'No query available'
+          ) as blocking_query
+        FROM BlockingTree bt
+        LEFT JOIN sys.dm_exec_sessions bs ON bt.blocking_session_id = bs.session_id
+        LEFT JOIN sys.dm_exec_connections bc ON bt.blocking_session_id = bc.session_id
+        ORDER BY bt.wait_time_seconds DESC
+      `;
+            const result = await client.query(query);
+            return {
+                blockingCount: result.length,
+                chains: result,
+            };
+        },
+    },
+    get_wait_stats: {
+        description: 'Get aggregated wait statistics to identify performance bottlenecks',
+        inputSchema: z.object({
+            top: z.number().optional().default(20).describe('Number of top waits to return'),
+            excludeIdle: z.boolean().optional().default(true).describe('Exclude idle and benign waits'),
+        }),
+        handler: async (client, args) => {
+            const excludeFilter = args.excludeIdle
+                ? `WHERE wait_type NOT IN (
+            'CLR_SEMAPHORE', 'LAZYWRITER_SLEEP', 'RESOURCE_QUEUE', 'SLEEP_TASK',
+            'SLEEP_SYSTEMTASK', 'SQLTRACE_BUFFER_FLUSH', 'WAITFOR', 'LOGMGR_QUEUE',
+            'CHECKPOINT_QUEUE', 'REQUEST_FOR_DEADLOCK_SEARCH', 'XE_TIMER_EVENT',
+            'BROKER_TO_FLUSH', 'BROKER_TASK_STOP', 'CLR_MANUAL_EVENT',
+            'CLR_AUTO_EVENT', 'DISPATCHER_QUEUE_SEMAPHORE', 'FT_IFTS_SCHEDULER_IDLE_WAIT',
+            'XE_DISPATCHER_WAIT', 'XE_DISPATCHER_JOIN', 'BROKER_EVENTHANDLER',
+            'TRACEWRITE', 'FT_IFTSHC_MUTEX', 'SQLTRACE_INCREMENTAL_FLUSH_SLEEP',
+            'BROKER_RECEIVE_WAITFOR', 'ONDEMAND_TASK_QUEUE', 'DBMIRROR_EVENTS_QUEUE',
+            'DBMIRRORING_CMD', 'BROKER_TRANSMITTER', 'SQLTRACE_WAIT_ENTRIES',
+            'SLEEP_BPOOL_FLUSH', 'SQLTRACE_LOCK', 'HADR_FILESTREAM_IOMGR_IOCOMPLETION',
+            'DIRTY_PAGE_POLL', 'SP_SERVER_DIAGNOSTICS_SLEEP'
+          )
+          AND wait_type NOT LIKE 'PREEMPTIVE_%'
+          AND wait_type NOT LIKE 'BROKER_%'
+          AND wait_type NOT LIKE 'SLEEP_%'`
+                : '';
+            const query = `
+        SELECT TOP ${args.top || 20}
+          wait_type,
+          waiting_tasks_count,
+          wait_time_ms,
+          max_wait_time_ms,
+          signal_wait_time_ms,
+          wait_time_ms - signal_wait_time_ms as resource_wait_time_ms,
+          CAST(100.0 * wait_time_ms / SUM(wait_time_ms) OVER() AS DECIMAL(5,2)) as pct_of_total
+        FROM sys.dm_os_wait_stats
+        ${excludeFilter}
+        ORDER BY wait_time_ms DESC
+      `;
+            return await client.query(query);
+        },
+    },
+    get_cpu_usage: {
+        description: 'Get CPU usage history for SQL Server from ring buffer',
+        inputSchema: z.object({
+            minutes: z.number().optional().default(30).describe('Minutes of history to retrieve'),
+        }),
+        handler: async (client, args) => {
+            const query = `
+        DECLARE @ts_now BIGINT = (SELECT cpu_ticks/(cpu_ticks/ms_ticks) FROM sys.dm_os_sys_info);
+
+        SELECT TOP ${args.minutes || 30}
+          DATEADD(ms, -1 * (@ts_now - [timestamp]), GETDATE()) as event_time,
+          SQLProcessUtilization as sql_cpu_percent,
+          SystemIdle as system_idle_percent,
+          100 - SystemIdle - SQLProcessUtilization as other_cpu_percent
+        FROM (
+          SELECT
+            record.value('(./Record/@id)[1]', 'int') as record_id,
+            record.value('(./Record/SchedulerMonitorEvent/SystemHealth/SystemIdle)[1]', 'int') as SystemIdle,
+            record.value('(./Record/SchedulerMonitorEvent/SystemHealth/ProcessUtilization)[1]', 'int') as SQLProcessUtilization,
+            [timestamp]
+          FROM (
+            SELECT [timestamp], CONVERT(xml, record) as record
+            FROM sys.dm_os_ring_buffers
+            WHERE ring_buffer_type = N'RING_BUFFER_SCHEDULER_MONITOR'
+            AND record LIKE '%<SystemHealth>%'
+          ) AS x
+        ) AS y
+        ORDER BY record_id DESC
+      `;
+            return await client.query(query);
+        },
+    },
+    get_index_usage: {
+        description: 'Get index usage statistics to identify unused or missing indexes',
+        inputSchema: z.object({
+            database: z.string().describe('Database name to analyze'),
+            showUnused: z.boolean().optional().default(true).describe('Include unused indexes'),
+        }),
+        handler: async (client, args) => {
+            const unusedFilter = args.showUnused
+                ? ''
+                : 'AND (user_seeks + user_scans + user_lookups) > 0';
+            const query = `
+        USE [${args.database}];
+
+        SELECT
+          OBJECT_SCHEMA_NAME(i.object_id) as schema_name,
+          OBJECT_NAME(i.object_id) as table_name,
+          i.name as index_name,
+          i.type_desc as index_type,
+          ISNULL(s.user_seeks, 0) as user_seeks,
+          ISNULL(s.user_scans, 0) as user_scans,
+          ISNULL(s.user_lookups, 0) as user_lookups,
+          ISNULL(s.user_updates, 0) as user_updates,
+          ISNULL(s.last_user_seek, '1900-01-01') as last_user_seek,
+          ISNULL(s.last_user_scan, '1900-01-01') as last_user_scan,
+          CAST(ps.used_page_count * 8.0 / 1024 AS DECIMAL(10,2)) as size_mb
+        FROM sys.indexes i
+        LEFT JOIN sys.dm_db_index_usage_stats s
+          ON i.object_id = s.object_id AND i.index_id = s.index_id AND s.database_id = DB_ID()
+        LEFT JOIN sys.dm_db_partition_stats ps
+          ON i.object_id = ps.object_id AND i.index_id = ps.index_id
+        WHERE OBJECTPROPERTY(i.object_id, 'IsUserTable') = 1
+        AND i.index_id > 0
+        ${unusedFilter}
+        ORDER BY (ISNULL(s.user_seeks, 0) + ISNULL(s.user_scans, 0) + ISNULL(s.user_lookups, 0)) ASC
+      `;
+            return await client.query(query);
+        },
+    },
+};
+//# sourceMappingURL=performance.js.map

package/dist/tools/performance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.js","sourceRoot":"","sources":["../../src/tools/performance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,YAAY,EAAE;QACZ,WAAW,EAAE,mEAAmE;QAChF,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC;QACzB,OAAO,EAAE,KAAK,EAAE,MAAmB,EAAE,EAAE;YACrC,MAAM,KAAK,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCb,CAAC;YAEF,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,OAAO;gBACL,aAAa,EAAE,MAAM,CAAC,MAAM;gBAC5B,MAAM,EAAE,MAAM;aACf,CAAC;QACJ,CAAC;KACF;IAED,cAAc,EAAE;QACd,WAAW,EAAE,oEAAoE;QACjF,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC;YACpB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,+BAA+B,CAAC;YAChF,WAAW,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,+BAA+B,CAAC;SAC5F,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,MAAmB,EAAE,IAA6C,EAAE,EAAE;YACpF,MAAM,aAAa,GAAG,IAAI,CAAC,WAAW;gBACpC,CAAC,CAAC;;;;;;;;;;;;;;;2CAeiC;gBACnC,CAAC,CAAC,EAAE,CAAC;YAEP,MAAM,KAAK,GAAG;qBACC,IAAI,CAAC,GAAG,IAAI,EAAE;;;;;;;;;UASzB,aAAa;;OAEhB,CAAC;YAEF,OAAO,MAAM,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC;KACF;IAED,aAAa,EAAE;QACb,WAAW,EAAE,uDAAuD;QACpE,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC;YACpB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,gCAAgC,CAAC;SACtF,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,MAAmB,EAAE,IAA0B,EAAE,EAAE;YACjE,MAAM,KAAK,GAAG;;;qBAGC,IAAI,CAAC,OAAO,IAAI,EAAE;;;;;;;;;;;;;;;;;;;OAmBhC,CAAC;YAEF,OAAO,MAAM,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC;KACF;IAED,eAAe,EAAE;QACf,WAAW,EAAE,kEAAkE;QAC/E,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC;YACpB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,0BAA0B,CAAC;YACzD,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,wBAAwB,CAAC;SACpF,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,MAAmB,EAAE,IAAgD,EAAE,EAAE;YACvF,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU;gBAClC,CAAC,CAAC,EAAE;gBACJ,CAAC,CAAC,kDAAkD,CAAC;YAEvD,MAAM,KAAK,GAAG;eACL,IAAI,CAAC,QAAQ;;;;;;;;;;;;;;;;;;;;;UAqBlB,YAAY;;OAEf,CAAC;YAEF,OAAO,MAAM,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC;KACF;CACF,CAAC"}

package/dist/tools/queries.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { MssqlClient } from '../mssqlClient.js';
+export declare const queryTools: {
+    execute_query: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            query: z.ZodString;
+            database: z.ZodOptional<z.ZodString>;
+            maxRows: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            query: string;
+            maxRows: number;
+            database?: string | undefined;
+        }, {
+            query: string;
+            database?: string | undefined;
+            maxRows?: number | undefined;
+        }>;
+        handler: (client: MssqlClient, args: {
+            query: string;
+            database?: string;
+            maxRows?: number;
+        }) => Promise<{
+            rowCount: number;
+            rows: import("mssql").IRecordSet<unknown>[];
+        }>;
+    };
+    get_expensive_queries: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            metric: z.ZodDefault<z.ZodOptional<z.ZodEnum<["cpu", "reads", "writes", "duration", "executions"]>>>;
+            top: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            metric: "cpu" | "reads" | "writes" | "duration" | "executions";
+            top: number;
+        }, {
+            metric?: "cpu" | "reads" | "writes" | "duration" | "executions" | undefined;
+            top?: number | undefined;
+        }>;
+        handler: (client: MssqlClient, args: {
+            metric?: string;
+            top?: number;
+        }) => Promise<import("mssql").IRecordSet<unknown>[]>;
+    };
+    get_running_queries: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            includeSystem: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            includeSystem: boolean;
+        }, {
+            includeSystem?: boolean | undefined;
+        }>;
+        handler: (client: MssqlClient, args: {
+            includeSystem?: boolean;
+        }) => Promise<import("mssql").IRecordSet<unknown>[]>;
+    };
+};
+//# sourceMappingURL=queries.d.ts.map

package/dist/tools/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../src/tools/queries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;0BAQK,WAAW,QAAQ;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE;;;;;;;;;;;;;;;;;0BA0CzE,WAAW,QAAQ;YAAE,MAAM,CAAC,EAAE,MAAM,CAAC;YAAC,GAAG,CAAC,EAAE,MAAM,CAAA;SAAE;;;;;;;;;;;0BA2CpD,WAAW,QAAQ;YAAE,aAAa,CAAC,EAAE,OAAO,CAAA;SAAE;;CAyCzE,CAAC"}

package/dist/tools/queries.js

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+export const queryTools = {
+    execute_query: {
+        description: 'Execute a read-only SQL query. Only SELECT statements are allowed for safety.',
+        inputSchema: z.object({
+            query: z.string().describe('The SQL SELECT query to execute'),
+            database: z.string().optional().describe('Database to run the query against (optional, uses default if not specified)'),
+            maxRows: z.number().optional().default(1000).describe('Maximum rows to return (default: 1000)'),
+        }),
+        handler: async (client, args) => {
+            // Safety check: only allow SELECT statements
+            const trimmedQuery = args.query.trim().toUpperCase();
+            if (!trimmedQuery.startsWith('SELECT') && !trimmedQuery.startsWith('WITH')) {
+                throw new Error('Only SELECT queries are allowed. For safety, INSERT/UPDATE/DELETE/EXEC are not permitted.');
+            }
+            // Check for dangerous keywords
+            const dangerous = ['INSERT', 'UPDATE', 'DELETE', 'DROP', 'TRUNCATE', 'ALTER', 'CREATE', 'EXEC', 'EXECUTE', 'XP_', 'SP_'];
+            for (const keyword of dangerous) {
+                if (trimmedQuery.includes(keyword) && !trimmedQuery.startsWith('WITH')) {
+                    throw new Error(`Query contains forbidden keyword: ${keyword}`);
+                }
+            }
+            let finalQuery = args.query;
+            // Add TOP clause if not present and maxRows specified
+            if (args.maxRows && !trimmedQuery.includes('TOP')) {
+                finalQuery = args.query.replace(/^SELECT/i, `SELECT TOP ${args.maxRows}`);
+            }
+            // Switch database if specified
+            if (args.database) {
+                finalQuery = `USE [${args.database}]; ${finalQuery}`;
+            }
+            const result = await client.query(finalQuery);
+            return {
+                rowCount: result.length,
+                rows: result,
+            };
+        },
+    },
+    get_expensive_queries: {
+        description: 'Get the most resource-intensive queries from the query store or plan cache',
+        inputSchema: z.object({
+            metric: z.enum(['cpu', 'reads', 'writes', 'duration', 'executions']).optional().default('cpu')
+                .describe('Metric to sort by'),
+            top: z.number().optional().default(20).describe('Number of queries to return'),
+        }),
+        handler: async (client, args) => {
+            const orderByMap = {
+                cpu: 'total_worker_time',
+                reads: 'total_logical_reads',
+                writes: 'total_logical_writes',
+                duration: 'total_elapsed_time',
+                executions: 'execution_count',
+            };
+            const orderBy = orderByMap[args.metric || 'cpu'];
+            const query = `
+        SELECT TOP ${args.top || 20}
+          qs.execution_count,
+          qs.total_worker_time / 1000 as total_cpu_ms,
+          qs.total_worker_time / qs.execution_count / 1000 as avg_cpu_ms,
+          qs.total_elapsed_time / 1000 as total_duration_ms,
+          qs.total_elapsed_time / qs.execution_count / 1000 as avg_duration_ms,
+          qs.total_logical_reads,
+          qs.total_logical_reads / qs.execution_count as avg_logical_reads,
+          qs.total_logical_writes,
+          qs.last_execution_time,
+          SUBSTRING(st.text, (qs.statement_start_offset/2)+1,
+            ((CASE qs.statement_end_offset
+              WHEN -1 THEN DATALENGTH(st.text)
+              ELSE qs.statement_end_offset
+            END - qs.statement_start_offset)/2)+1) as query_text,
+          DB_NAME(st.dbid) as database_name
+        FROM sys.dm_exec_query_stats qs
+        CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) st
+        WHERE qs.execution_count > 0
+        ORDER BY ${orderBy} DESC
+      `;
+            return await client.query(query);
+        },
+    },
+    get_running_queries: {
+        description: 'Get currently executing queries with their status and resource usage',
+        inputSchema: z.object({
+            includeSystem: z.boolean().optional().default(false).describe('Include system processes'),
+        }),
+        handler: async (client, args) => {
+            const systemFilter = args.includeSystem ? '' : 'AND s.is_user_process = 1';
+            const query = `
+        SELECT
+          r.session_id,
+          r.request_id,
+          r.start_time,
+          DATEDIFF(SECOND, r.start_time, GETDATE()) as duration_seconds,
+          r.status,
+          r.command,
+          r.database_id,
+          DB_NAME(r.database_id) as database_name,
+          r.wait_type,
+          r.wait_time,
+          r.blocking_session_id,
+          r.cpu_time,
+          r.total_elapsed_time,
+          r.reads,
+          r.writes,
+          r.logical_reads,
+          s.login_name,
+          s.host_name,
+          s.program_name,
+          SUBSTRING(st.text, (r.statement_start_offset/2)+1,
+            ((CASE r.statement_end_offset
+              WHEN -1 THEN DATALENGTH(st.text)
+              ELSE r.statement_end_offset
+            END - r.statement_start_offset)/2)+1) as current_statement,
+          st.text as full_query
+        FROM sys.dm_exec_requests r
+        INNER JOIN sys.dm_exec_sessions s ON r.session_id = s.session_id
+        CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) st
+        WHERE r.session_id != @@SPID
+        ${systemFilter}
+        ORDER BY r.total_elapsed_time DESC
+      `;
+            return await client.query(query);
+        },
+    },
+};
+//# sourceMappingURL=queries.js.map

package/dist/tools/queries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.js","sourceRoot":"","sources":["../../src/tools/queries.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@elad-nofy/mssql-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Microsoft SQL Server - Query execution, performance analysis, health monitoring",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "mssql-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "mssql",
+    "sql-server",
+    "database",
+    "model-context-protocol",
+    "claude",
+    "ai",
+    "observability",
+    "monitoring"
+  ],
+  "author": "Nof Yonany",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/elad-nofy/mssql-mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/elad-nofy/mssql-mcp/issues"
+  },
+  "homepage": "https://github.com/elad-nofy/mssql-mcp#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "mssql": "^11.0.1",
+    "zod": "^3.24.1",
+    "zod-to-json-schema": "^3.25.1"
+  },
+  "devDependencies": {
+    "@types/mssql": "^9.1.5",
+    "@types/node": "^22.10.5",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}