@neverinfamous/mysql-mcp 2.1.0

package/src/adapters/mysql/types/__tests__/shell-types.test.ts

@@ -0,0 +1,210 @@
+/**
+ * mysql-mcp - Shell Types Unit Tests
+ * 
+ * Tests for shell-types.ts boolean coercion and schema validation.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+    ShellImportTableInputSchema,
+    ShellDumpInstanceInputSchema,
+    ShellDumpSchemasInputSchema,
+    ShellDumpTablesInputSchema,
+    ShellLoadDumpInputSchema,
+    ShellImportJSONInputSchema
+} from '../shell-types.js';
+
+describe('Shell Types - Boolean Coercion', () => {
+    describe('ShellImportTableInputSchema', () => {
+        it('should coerce string "true" to boolean true', () => {
+            const result = ShellImportTableInputSchema.parse({
+                inputPath: '/path/to/file',
+                schema: 'test',
+                table: 'users',
+                updateServerSettings: 'true'
+            });
+            expect(result.updateServerSettings).toBe(true);
+        });
+
+        it('should coerce string "false" to boolean false', () => {
+            const result = ShellImportTableInputSchema.parse({
+                inputPath: '/path/to/file',
+                schema: 'test',
+                table: 'users',
+                updateServerSettings: 'false'
+            });
+            expect(result.updateServerSettings).toBe(false);
+        });
+
+        it('should coerce string "TRUE" (uppercase) to boolean true', () => {
+            const result = ShellImportTableInputSchema.parse({
+                inputPath: '/path/to/file',
+                schema: 'test',
+                table: 'users',
+                updateServerSettings: 'TRUE'
+            });
+            expect(result.updateServerSettings).toBe(true);
+        });
+
+        it('should coerce string "FALSE" (uppercase) to boolean false', () => {
+            const result = ShellImportTableInputSchema.parse({
+                inputPath: '/path/to/file',
+                schema: 'test',
+                table: 'users',
+                updateServerSettings: 'FALSE'
+            });
+            expect(result.updateServerSettings).toBe(false);
+        });
+
+        it('should pass through boolean true unchanged', () => {
+            const result = ShellImportTableInputSchema.parse({
+                inputPath: '/path/to/file',
+                schema: 'test',
+                table: 'users',
+                updateServerSettings: true
+            });
+            expect(result.updateServerSettings).toBe(true);
+        });
+
+        it('should pass through boolean false unchanged', () => {
+            const result = ShellImportTableInputSchema.parse({
+                inputPath: '/path/to/file',
+                schema: 'test',
+                table: 'users',
+                updateServerSettings: false
+            });
+            expect(result.updateServerSettings).toBe(false);
+        });
+
+        it('should reject invalid string values', () => {
+            expect(() => ShellImportTableInputSchema.parse({
+                inputPath: '/path/to/file',
+                schema: 'test',
+                table: 'users',
+                updateServerSettings: 'yes'
+            })).toThrow();
+        });
+    });
+
+    describe('ShellDumpInstanceInputSchema', () => {
+        it('should coerce dryRun string to boolean', () => {
+            const result = ShellDumpInstanceInputSchema.parse({
+                outputDir: '/backup',
+                dryRun: 'true'
+            });
+            expect(result.dryRun).toBe(true);
+        });
+
+        it('should coerce consistent string to boolean', () => {
+            const result = ShellDumpInstanceInputSchema.parse({
+                outputDir: '/backup',
+                consistent: 'false'
+            });
+            expect(result.consistent).toBe(false);
+        });
+
+        it('should coerce users string to boolean', () => {
+            const result = ShellDumpInstanceInputSchema.parse({
+                outputDir: '/backup',
+                users: 'true'
+            });
+            expect(result.users).toBe(true);
+        });
+    });
+
+    describe('ShellDumpSchemasInputSchema', () => {
+        it('should coerce dryRun string to boolean', () => {
+            const result = ShellDumpSchemasInputSchema.parse({
+                schemas: ['db1'],
+                outputDir: '/backup',
+                dryRun: 'true'
+            });
+            expect(result.dryRun).toBe(true);
+        });
+
+        it('should coerce ddlOnly string to boolean', () => {
+            const result = ShellDumpSchemasInputSchema.parse({
+                schemas: ['db1'],
+                outputDir: '/backup',
+                ddlOnly: 'true'
+            });
+            expect(result.ddlOnly).toBe(true);
+        });
+    });
+
+    describe('ShellDumpTablesInputSchema', () => {
+        it('should coerce all string to boolean', () => {
+            const result = ShellDumpTablesInputSchema.parse({
+                schema: 'db1',
+                tables: ['t1'],
+                outputDir: '/backup',
+                all: 'true'
+            });
+            expect(result.all).toBe(true);
+        });
+    });
+
+    describe('ShellLoadDumpInputSchema', () => {
+        it('should coerce dryRun string to boolean', () => {
+            const result = ShellLoadDumpInputSchema.parse({
+                inputDir: '/backup',
+                dryRun: 'true'
+            });
+            expect(result.dryRun).toBe(true);
+        });
+
+        it('should coerce ignoreExistingObjects string to boolean', () => {
+            const result = ShellLoadDumpInputSchema.parse({
+                inputDir: '/backup',
+                ignoreExistingObjects: 'true'
+            });
+            expect(result.ignoreExistingObjects).toBe(true);
+        });
+
+        it('should coerce ignoreVersion string to boolean', () => {
+            const result = ShellLoadDumpInputSchema.parse({
+                inputDir: '/backup',
+                ignoreVersion: 'true'
+            });
+            expect(result.ignoreVersion).toBe(true);
+        });
+
+        it('should coerce resetProgress string to boolean', () => {
+            const result = ShellLoadDumpInputSchema.parse({
+                inputDir: '/backup',
+                resetProgress: 'true'
+            });
+            expect(result.resetProgress).toBe(true);
+        });
+
+        it('should coerce updateServerSettings string to boolean', () => {
+            const result = ShellLoadDumpInputSchema.parse({
+                inputDir: '/backup',
+                updateServerSettings: 'true'
+            });
+            expect(result.updateServerSettings).toBe(true);
+        });
+    });
+
+    describe('ShellImportJSONInputSchema', () => {
+        it('should coerce convertBsonTypes string to boolean', () => {
+            const result = ShellImportJSONInputSchema.parse({
+                inputPath: '/data.json',
+                schema: 'test',
+                collection: 'docs',
+                convertBsonTypes: 'true'
+            });
+            expect(result.convertBsonTypes).toBe(true);
+        });
+
+        it('should coerce convertBsonTypes string false to boolean', () => {
+            const result = ShellImportJSONInputSchema.parse({
+                inputPath: '/data.json',
+                schema: 'test',
+                collection: 'docs',
+                convertBsonTypes: 'false'
+            });
+            expect(result.convertBsonTypes).toBe(false);
+        });
+    });
+});

package/src/adapters/mysql/types/proxysql-types.ts

@@ -0,0 +1,190 @@
+/**
+ * ProxySQL Types and Schemas
+ * 
+ * Type definitions and Zod validation schemas for ProxySQL admin interface tools.
+ * ProxySQL uses MySQL-protocol compatible admin interface on port 6032.
+ */
+
+import { z } from 'zod';
+
+// =============================================================================
+// ProxySQL Configuration
+// =============================================================================
+
+export const ProxySQLConfigSchema = z.object({
+    host: z.string().default('localhost'),
+    port: z.number().default(6032),
+    user: z.string().default('admin'),
+    password: z.string().default('admin')
+});
+
+export type ProxySQLConfig = z.infer<typeof ProxySQLConfigSchema>;
+
+// =============================================================================
+// Stats Response Types
+// =============================================================================
+
+export const ProxySQLServerSchema = z.object({
+    hostgroup_id: z.number(),
+    hostname: z.string(),
+    port: z.number(),
+    status: z.string(),
+    weight: z.number().optional(),
+    compression: z.number().optional(),
+    max_connections: z.number().optional(),
+    max_replication_lag: z.number().optional(),
+    use_ssl: z.number().optional(),
+    max_latency_ms: z.number().optional(),
+    comment: z.string().optional()
+});
+
+export type ProxySQLServer = z.infer<typeof ProxySQLServerSchema>;
+
+export const ProxySQLHostgroupSchema = z.object({
+    hostgroup_id: z.number(),
+    hostname: z.string(),
+    port: z.number(),
+    status: z.string(),
+    ConnUsed: z.number().optional(),
+    ConnFree: z.number().optional(),
+    ConnOK: z.number().optional(),
+    ConnERR: z.number().optional(),
+    MaxConnUsed: z.number().optional(),
+    Queries: z.number().optional(),
+    Bytes_data_sent: z.number().optional(),
+    Bytes_data_recv: z.number().optional(),
+    Latency_us: z.number().optional()
+});
+
+export type ProxySQLHostgroup = z.infer<typeof ProxySQLHostgroupSchema>;
+
+export const ProxySQLQueryRuleSchema = z.object({
+    rule_id: z.number(),
+    active: z.number().optional(),
+    username: z.string().optional(),
+    schemaname: z.string().optional(),
+    match_digest: z.string().optional(),
+    match_pattern: z.string().optional(),
+    destination_hostgroup: z.number().optional(),
+    cache_ttl: z.number().optional(),
+    multiplex: z.number().optional(),
+    flagOUT: z.number().optional(),
+    comment: z.string().optional()
+});
+
+export type ProxySQLQueryRule = z.infer<typeof ProxySQLQueryRuleSchema>;
+
+export const ProxySQLQueryDigestSchema = z.object({
+    hostgroup: z.number(),
+    schemaname: z.string(),
+    username: z.string(),
+    digest: z.string(),
+    digest_text: z.string(),
+    count_star: z.number(),
+    first_seen: z.number().optional(),
+    last_seen: z.number().optional(),
+    sum_time: z.number().optional(),
+    min_time: z.number().optional(),
+    max_time: z.number().optional()
+});
+
+export type ProxySQLQueryDigest = z.infer<typeof ProxySQLQueryDigestSchema>;
+
+export const ProxySQLConnectionPoolSchema = z.object({
+    hostgroup: z.number(),
+    srv_host: z.string(),
+    srv_port: z.number(),
+    status: z.string(),
+    ConnUsed: z.number(),
+    ConnFree: z.number(),
+    ConnOK: z.number(),
+    ConnERR: z.number(),
+    MaxConnUsed: z.number(),
+    Queries: z.number(),
+    Bytes_data_sent: z.number(),
+    Bytes_data_recv: z.number(),
+    Latency_us: z.number()
+});
+
+export type ProxySQLConnectionPool = z.infer<typeof ProxySQLConnectionPoolSchema>;
+
+export const ProxySQLUserSchema = z.object({
+    username: z.string(),
+    password: z.string().optional(),
+    active: z.number().optional(),
+    use_ssl: z.number().optional(),
+    default_hostgroup: z.number().optional(),
+    default_schema: z.string().optional(),
+    transaction_persistent: z.number().optional(),
+    max_connections: z.number().optional(),
+    comment: z.string().optional()
+});
+
+export type ProxySQLUser = z.infer<typeof ProxySQLUserSchema>;
+
+export const ProxySQLGlobalVariableSchema = z.object({
+    variable_name: z.string(),
+    variable_value: z.string()
+});
+
+export type ProxySQLGlobalVariable = z.infer<typeof ProxySQLGlobalVariableSchema>;
+
+export const ProxySQLMemoryStatsSchema = z.object({
+    Variable_Name: z.string(),
+    Variable_Value: z.string()
+});
+
+export type ProxySQLMemoryStats = z.infer<typeof ProxySQLMemoryStatsSchema>;
+
+export const ProxySQLProcessSchema = z.object({
+    SessionID: z.number().optional(),
+    user: z.string().optional(),
+    db: z.string().optional(),
+    cli_host: z.string().optional(),
+    cli_port: z.number().optional(),
+    hostgroup: z.number().optional(),
+    srv_host: z.string().optional(),
+    srv_port: z.number().optional(),
+    command: z.string().optional(),
+    time_ms: z.number().optional(),
+    info: z.string().optional()
+});
+
+export type ProxySQLProcess = z.infer<typeof ProxySQLProcessSchema>;
+
+// =============================================================================
+// Tool Input Schemas
+// =============================================================================
+
+export const ProxySQLBaseInputSchema = z.object({});
+
+export const ProxySQLLimitInputSchema = z.object({
+    limit: z.number().optional().describe('Maximum number of results to return (default: 100)')
+});
+
+export const ProxySQLHostgroupInputSchema = z.object({
+    hostgroup_id: z.number().optional().describe('Filter by hostgroup ID')
+});
+
+export const ProxySQLVariableFilterSchema = z.object({
+    prefix: z.enum(['mysql', 'admin', 'all']).optional().describe('Variable prefix filter: mysql, admin, or all (default: all)')
+});
+
+export const ProxySQLCommandInputSchema = z.object({
+    command: z.enum([
+        'LOAD MYSQL USERS TO RUNTIME',
+        'SAVE MYSQL USERS TO DISK',
+        'LOAD MYSQL SERVERS TO RUNTIME',
+        'SAVE MYSQL SERVERS TO DISK',
+        'LOAD MYSQL QUERY RULES TO RUNTIME',
+        'SAVE MYSQL QUERY RULES TO DISK',
+        'LOAD MYSQL VARIABLES TO RUNTIME',
+        'SAVE MYSQL VARIABLES TO DISK',
+        'LOAD ADMIN VARIABLES TO RUNTIME',
+        'SAVE ADMIN VARIABLES TO DISK',
+        'PROXYSQL FLUSH QUERY CACHE',
+        'PROXYSQL FLUSH LOGS'
+    ]).describe('ProxySQL admin command to execute')
+});
+
+export type ProxySQLCommand = z.infer<typeof ProxySQLCommandInputSchema>['command'];

package/src/adapters/mysql/types/router-types.ts

@@ -0,0 +1,129 @@
+/**
+ * MySQL Router Types and Schemas
+ * 
+ * Type definitions and Zod validation schemas for MySQL Router REST API tools.
+ */
+
+import { z } from 'zod';
+
+// =============================================================================
+// Router Status Types
+// =============================================================================
+
+export const RouterStatusResponseSchema = z.object({
+    processId: z.number().optional(),
+    productEdition: z.string().optional(),
+    timeStarted: z.string().optional(),
+    version: z.string().optional(),
+    hostname: z.string().optional()
+});
+
+export type RouterStatusResponse = z.infer<typeof RouterStatusResponseSchema>;
+
+// =============================================================================
+// Route Types
+// =============================================================================
+
+export const RouteSchema = z.object({
+    name: z.string()
+});
+
+export const RouteListSchema = z.object({
+    items: z.array(RouteSchema)
+});
+
+export type RouteList = z.infer<typeof RouteListSchema>;
+
+export const RouteStatusSchema = z.object({
+    activeConnections: z.number().optional(),
+    totalConnections: z.number().optional(),
+    blockedHosts: z.number().optional()
+});
+
+export type RouteStatus = z.infer<typeof RouteStatusSchema>;
+
+export const RouteHealthSchema = z.object({
+    isAlive: z.boolean()
+});
+
+export type RouteHealth = z.infer<typeof RouteHealthSchema>;
+
+export const RouteConnectionSchema = z.object({
+    bytesFromServer: z.number().optional(),
+    bytesToServer: z.number().optional(),
+    sourceAddress: z.string().optional(),
+    destinationAddress: z.string().optional(),
+    timeStarted: z.string().optional(),
+    timeConnectedToServer: z.string().optional()
+});
+
+export const RouteConnectionsListSchema = z.object({
+    items: z.array(RouteConnectionSchema)
+});
+
+export type RouteConnectionsList = z.infer<typeof RouteConnectionsListSchema>;
+
+export const RouteDestinationSchema = z.object({
+    address: z.string(),
+    port: z.number()
+});
+
+export const RouteDestinationsListSchema = z.object({
+    items: z.array(RouteDestinationSchema)
+});
+
+export type RouteDestinationsList = z.infer<typeof RouteDestinationsListSchema>;
+
+export const BlockedHostSchema = z.object({
+    hostname: z.string()
+});
+
+export const BlockedHostsListSchema = z.object({
+    items: z.array(BlockedHostSchema)
+});
+
+export type BlockedHostsList = z.infer<typeof BlockedHostsListSchema>;
+
+// =============================================================================
+// Metadata Types
+// =============================================================================
+
+export const MetadataStatusSchema = z.object({
+    refreshFailed: z.number().optional(),
+    refreshSucceeded: z.number().optional(),
+    lastRefreshHostname: z.string().optional(),
+    lastRefreshPort: z.number().optional(),
+    timeLastRefreshSucceeded: z.string().optional(),
+    timeLastRefreshFailed: z.string().optional()
+});
+
+export type MetadataStatus = z.infer<typeof MetadataStatusSchema>;
+
+// =============================================================================
+// Connection Pool Types
+// =============================================================================
+
+export const ConnectionPoolStatusSchema = z.object({
+    reusedConnections: z.number().optional(),
+    idleServerConnections: z.number().optional()
+});
+
+export type ConnectionPoolStatus = z.infer<typeof ConnectionPoolStatusSchema>;
+
+// =============================================================================
+// Tool Input Schemas
+// =============================================================================
+
+export const RouterBaseInputSchema = z.object({});
+
+export const RouteNameInputSchema = z.object({
+    routeName: z.string().describe('Name of the route to query')
+});
+
+export const MetadataNameInputSchema = z.object({
+    metadataName: z.string().describe('Name of the metadata cache instance')
+});
+
+export const ConnectionPoolNameInputSchema = z.object({
+    poolName: z.string().describe('Name of the connection pool')
+});

package/src/adapters/mysql/types/shell-types.ts

@@ -0,0 +1,140 @@
+/**
+ * MySQL Shell Tool Type Definitions
+ * 
+ * Zod schemas for MySQL Shell tool inputs.
+ * Tools execute mysqlsh as a subprocess to access util.* functions.
+ */
+
+import { z } from 'zod';
+
+// =============================================================================
+// Helper for boolean coercion (handles string "true"/"false" from MCP clients)
+// =============================================================================
+
+const booleanCoerce = z.preprocess(
+    (val) => {
+        if (typeof val === 'string') {
+            if (val.toLowerCase() === 'true') return true;
+            if (val.toLowerCase() === 'false') return false;
+        }
+        return val;
+    },
+    z.boolean()
+);
+
+// =============================================================================
+// Base Schema
+// =============================================================================
+
+export const ShellBaseInputSchema = z.object({}).describe('MySQL Shell base input');
+
+// =============================================================================
+// Info Tools
+// =============================================================================
+
+export const ShellVersionInputSchema = z.object({}).describe('Get MySQL Shell version and status');
+
+// =============================================================================
+// Utility Tools
+// =============================================================================
+
+export const ShellCheckUpgradeInputSchema = z.object({
+    targetVersion: z.string().optional().describe('Target MySQL version to check compatibility for (e.g., "8.0.40", "8.4.0")'),
+    outputFormat: z.enum(['TEXT', 'JSON']).optional().default('JSON').describe('Output format')
+}).describe('Check server upgrade compatibility using util.checkForServerUpgrade()');
+
+// =============================================================================
+// Data Transfer Tools
+// =============================================================================
+
+export const ShellExportTableInputSchema = z.object({
+    schema: z.string().describe('Source schema (database) name'),
+    table: z.string().describe('Table name to export'),
+    outputPath: z.string().describe('Output file path (absolute path recommended)'),
+    format: z.enum(['csv', 'tsv', 'json']).optional().default('csv').describe('Export format'),
+    where: z.string().optional().describe('WHERE clause for filtering rows (without WHERE keyword)')
+}).describe('Export table to file using util.exportTable()');
+
+export const ShellImportTableInputSchema = z.object({
+    inputPath: z.string().describe('Input file path (absolute path)'),
+    schema: z.string().describe('Target schema (database) name'),
+    table: z.string().describe('Target table name'),
+    threads: z.number().int().min(1).max(128).optional().default(4).describe('Number of parallel threads'),
+    skipRows: z.number().int().min(0).optional().describe('Number of header rows to skip'),
+    columns: z.array(z.string()).optional().describe('Column mapping for import'),
+    fieldsTerminatedBy: z.string().optional().describe('Field delimiter (default: auto-detect)'),
+    linesTerminatedBy: z.string().optional().describe('Line delimiter'),
+    updateServerSettings: booleanCoerce.optional().default(false).describe('Automatically enable local_infile on the server if disabled (requires SUPER or SYSTEM_VARIABLES_ADMIN privilege)')
+}).describe('Parallel table import using util.importTable()');
+
+export const ShellImportJSONInputSchema = z.object({
+    inputPath: z.string().describe('JSON file path (absolute path)'),
+    schema: z.string().describe('Target schema (database) name'),
+    collection: z.string().describe('Target collection or table name'),
+    tableColumn: z.string().optional().describe('Column name for JSON data when importing to table'),
+    convertBsonTypes: booleanCoerce.optional().default(false).describe('Convert BSON types from MongoDB exports')
+}).describe('Import JSON documents using util.importJson()');
+
+// =============================================================================
+// Backup Tools
+// =============================================================================
+
+export const ShellDumpInstanceInputSchema = z.object({
+    outputDir: z.string().describe('Output directory for dump (must be empty or non-existent)'),
+    threads: z.number().int().min(1).max(128).optional().default(4).describe('Number of parallel threads'),
+    compression: z.enum(['none', 'zstd', 'gzip']).optional().default('zstd').describe('Compression method'),
+    dryRun: booleanCoerce.optional().default(false).describe('Simulate dump without writing files'),
+    includeSchemas: z.array(z.string()).optional().describe('Schemas to include (default: all non-system)'),
+    excludeSchemas: z.array(z.string()).optional().describe('Schemas to exclude'),
+    consistent: booleanCoerce.optional().default(true).describe('Use consistent snapshot'),
+    users: booleanCoerce.optional().default(true).describe('Include user accounts and grants')
+}).describe('Dump entire MySQL instance using util.dumpInstance()');
+
+export const ShellDumpSchemasInputSchema = z.object({
+    schemas: z.array(z.string()).min(1).describe('Schema names to dump'),
+    outputDir: z.string().describe('Output directory for dump'),
+    threads: z.number().int().min(1).max(128).optional().default(4).describe('Number of parallel threads'),
+    compression: z.enum(['none', 'zstd', 'gzip']).optional().default('zstd').describe('Compression method'),
+    dryRun: booleanCoerce.optional().default(false).describe('Simulate dump without writing files'),
+    includeTables: z.array(z.string()).optional().describe('Tables to include (schema.table format)'),
+    excludeTables: z.array(z.string()).optional().describe('Tables to exclude (schema.table format)'),
+    ddlOnly: booleanCoerce.optional().default(false).describe('Dump only DDL (schema structure) without data or metadata requiring extra privileges (events, triggers, routines)')
+}).describe('Dump selected schemas using util.dumpSchemas()');
+
+export const ShellDumpTablesInputSchema = z.object({
+    schema: z.string().describe('Schema containing tables'),
+    tables: z.array(z.string()).min(1).describe('Table names to dump'),
+    outputDir: z.string().describe('Output directory for dump'),
+    threads: z.number().int().min(1).max(128).optional().default(4).describe('Number of parallel threads'),
+    compression: z.enum(['none', 'zstd', 'gzip']).optional().default('zstd').describe('Compression method'),
+    where: z.record(z.string(), z.string()).optional().describe('WHERE clauses per table ({tableName: "condition"})'),
+    all: booleanCoerce.optional().default(false).describe('Dump all metadata for tables (triggers, etc.). Set to false if lacking privileges.')
+}).describe('Dump specific tables using util.dumpTables()');
+
+// =============================================================================
+// Restore Tools
+// =============================================================================
+
+export const ShellLoadDumpInputSchema = z.object({
+    inputDir: z.string().describe('Directory containing MySQL Shell dump'),
+    threads: z.number().int().min(1).max(128).optional().default(4).describe('Number of parallel threads'),
+    dryRun: booleanCoerce.optional().default(false).describe('Simulate load without executing'),
+    includeSchemas: z.array(z.string()).optional().describe('Schemas to include'),
+    excludeSchemas: z.array(z.string()).optional().describe('Schemas to exclude'),
+    includeTables: z.array(z.string()).optional().describe('Tables to include (schema.table format)'),
+    excludeTables: z.array(z.string()).optional().describe('Tables to exclude'),
+    ignoreExistingObjects: booleanCoerce.optional().default(false).describe('Ignore existing objects instead of failing'),
+    ignoreVersion: booleanCoerce.optional().default(false).describe('Ignore version mismatch between dump and server'),
+    resetProgress: booleanCoerce.optional().default(false).describe('Reset progress tracking and reload from start'),
+    updateServerSettings: booleanCoerce.optional().default(false).describe('Automatically enable local_infile on the server if disabled (requires SUPER or SYSTEM_VARIABLES_ADMIN privilege)')
+}).describe('Load dump to instance using util.loadDump()');
+
+// =============================================================================
+// Scripting Tools
+// =============================================================================
+
+export const ShellRunScriptInputSchema = z.object({
+    script: z.string().min(1).describe('Script content to execute'),
+    language: z.enum(['js', 'py', 'sql']).describe('Script language (JavaScript, Python, or SQL)'),
+    timeout: z.number().int().min(1000).max(3600000).optional().default(60000).describe('Timeout in milliseconds (default: 60 seconds)')
+}).describe('Execute JavaScript, Python, or SQL script via MySQL Shell');