@neverinfamous/mysql-mcp 2.1.0

package/src/cli/args.ts

@@ -0,0 +1,343 @@
+import { parseMySQLConnectionString, DEFAULT_CONFIG } from '../server/McpServer.js';
+import type { McpServerConfig, TransportType, DatabaseConfig, PoolConfig, OAuthConfig } from '../types/index.js';
+
+/**
+ * Parse command line arguments
+ */
+export function parseArgs(argv: string[] = process.argv.slice(2)): {
+    config: Partial<McpServerConfig>;
+    databases: DatabaseConfig[];
+    oauth: OAuthConfig | undefined;
+    shouldExit: boolean;
+} {
+    const args = argv;
+    const config: Partial<McpServerConfig> = {};
+    const databases: DatabaseConfig[] = [];
+
+    // Default pool config
+    const poolConfig: PoolConfig = {
+        connectionLimit: 10,
+        waitForConnections: true,
+        queueLimit: 0
+    };
+
+    // OAuth config
+    let oauthEnabled = false;
+    let oauthIssuer: string | undefined;
+    let oauthAudience: string | undefined;
+    let oauthJwksUri: string | undefined;
+    let oauthClockTolerance: number | undefined;
+
+    // MySQL connection params
+    let mysqlHost: string | undefined;
+    let mysqlPort = 3306;
+    let mysqlUser: string | undefined;
+    let mysqlPassword: string | undefined;
+    let mysqlDatabase: string | undefined;
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const nextArg = args[i + 1];
+
+        switch (arg) {
+            case '--transport':
+            case '-t':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    config.transport = nextArg as TransportType;
+                    i++;
+                }
+                break;
+
+            case '--port':
+            case '-p':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    config.port = parseInt(nextArg, 10);
+                    i++;
+                }
+                break;
+
+            case '--mysql':
+            case '-m':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    // Parse connection string
+                    const dbConfig = parseMySQLConnectionString(nextArg);
+                    dbConfig.pool = poolConfig;
+                    databases.push(dbConfig);
+                    i++;
+                }
+                break;
+
+            case '--mysql-host':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    mysqlHost = nextArg;
+                    i++;
+                }
+                break;
+
+            case '--mysql-port':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    mysqlPort = parseInt(nextArg, 10);
+                    i++;
+                }
+                break;
+
+            case '--mysql-user':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    mysqlUser = nextArg;
+                    i++;
+                }
+                break;
+
+            case '--mysql-password':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    mysqlPassword = nextArg;
+                    i++;
+                }
+                break;
+
+            case '--mysql-database':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    mysqlDatabase = nextArg;
+                    i++;
+                }
+                break;
+
+            case '--pool-size':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    poolConfig.connectionLimit = parseInt(nextArg, 10);
+                    i++;
+                }
+                break;
+
+            case '--pool-timeout':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    poolConfig.acquireTimeout = parseInt(nextArg, 10);
+                    i++;
+                }
+                break;
+
+            case '--pool-queue-limit':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    poolConfig.queueLimit = parseInt(nextArg, 10);
+                    i++;
+                }
+                break;
+
+            case '--tool-filter':
+            case '-f':
+                // Note: tool filter values can start with '-' (e.g., "-base,-ecosystem,+starter")
+                // so we can't use the usual !nextArg.startsWith('-') check
+                if (nextArg !== undefined) {
+                    config.toolFilter = nextArg;
+                    i++;
+                }
+                break;
+
+            case '--name':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    config.name = nextArg;
+                    i++;
+                }
+                break;
+
+            // OAuth options
+            case '--oauth-enabled':
+            case '-o':
+                oauthEnabled = true;
+                break;
+
+            case '--oauth-issuer':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    oauthIssuer = nextArg;
+                    i++;
+                }
+                break;
+
+            case '--oauth-audience':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    oauthAudience = nextArg;
+                    i++;
+                }
+                break;
+
+            case '--oauth-jwks-uri':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    oauthJwksUri = nextArg;
+                    i++;
+                }
+                break;
+
+            case '--oauth-clock-tolerance':
+                if (nextArg && !nextArg.startsWith('-')) {
+                    oauthClockTolerance = parseInt(nextArg, 10);
+                    i++;
+                }
+                break;
+
+            case '--version':
+            case '-v':
+                console.error(`mysql-mcp version ${DEFAULT_CONFIG.version}`);
+                return { config, databases, oauth: undefined, shouldExit: true };
+
+            case '--help':
+            case '-h':
+                printHelp();
+                return { config, databases, oauth: undefined, shouldExit: true };
+
+            default:
+                if (arg?.startsWith('-')) {
+                    console.error(`Unknown option: ${arg}`);
+                    printHelp();
+                    process.exit(1);
+                }
+        }
+    }
+
+    // Build database config from individual params if provided
+    if (mysqlHost || mysqlUser || mysqlDatabase) {
+        // Check required fields
+        if (!mysqlHost) {
+            mysqlHost = process.env['MYSQL_HOST'] ?? 'localhost';
+        }
+        if (!mysqlUser) {
+            mysqlUser = process.env['MYSQL_USER'];
+        }
+        if (!mysqlPassword) {
+            mysqlPassword = process.env['MYSQL_PASSWORD'];
+        }
+        if (!mysqlDatabase) {
+            mysqlDatabase = process.env['MYSQL_DATABASE'];
+        }
+
+        if (mysqlUser && mysqlDatabase) {
+            databases.push({
+                type: 'mysql',
+                host: mysqlHost,
+                port: mysqlPort,
+                username: mysqlUser,
+                password: mysqlPassword,
+                database: mysqlDatabase,
+                pool: poolConfig
+            });
+        }
+    }
+
+    // Check environment variables as fallback
+    if (databases.length === 0) {
+        const envHost = process.env['MYSQL_HOST'];
+        const envUser = process.env['MYSQL_USER'];
+        const envPassword = process.env['MYSQL_PASSWORD'];
+        const envDatabase = process.env['MYSQL_DATABASE'];
+        const envPort = process.env['MYSQL_PORT'];
+        const envPoolSize = process.env['MYSQL_POOL_SIZE'];
+
+        if (envHost && envUser && envDatabase) {
+            if (envPoolSize) {
+                poolConfig.connectionLimit = parseInt(envPoolSize, 10);
+            }
+            databases.push({
+                type: 'mysql',
+                host: envHost,
+                port: envPort ? parseInt(envPort, 10) : 3306,
+                username: envUser,
+                password: envPassword,
+                database: envDatabase,
+                pool: poolConfig
+            });
+        }
+    }
+
+    // Check for tool filter in environment
+    if (!config.toolFilter) {
+        config.toolFilter = process.env['MYSQL_MCP_TOOL_FILTER'] ?? process.env['TOOL_FILTER'];
+    }
+
+    // Check OAuth environment variables
+    if (!oauthEnabled && process.env['OAUTH_ENABLED'] === 'true') {
+        oauthEnabled = true;
+    }
+    if (!oauthIssuer) {
+        oauthIssuer = process.env['OAUTH_ISSUER'];
+    }
+    if (!oauthAudience) {
+        oauthAudience = process.env['OAUTH_AUDIENCE'];
+    }
+    if (!oauthJwksUri) {
+        oauthJwksUri = process.env['OAUTH_JWKS_URI'];
+    }
+    if (oauthClockTolerance === undefined && process.env['OAUTH_CLOCK_TOLERANCE']) {
+        oauthClockTolerance = parseInt(process.env['OAUTH_CLOCK_TOLERANCE'], 10);
+    }
+
+    // Build OAuth config if enabled
+    let oauth: OAuthConfig | undefined;
+    if (oauthEnabled) {
+        oauth = {
+            enabled: true,
+            authorizationServerUrl: oauthIssuer,
+            issuer: oauthIssuer,
+            audience: oauthAudience,
+            jwksUri: oauthJwksUri,
+            clockTolerance: oauthClockTolerance
+        };
+    }
+
+    return { config, databases, oauth, shouldExit: false };
+}
+
+/**
+ * Print help message
+ */
+export function printHelp(): void {
+    console.error(`
+mysql-mcp - Enterprise MySQL MCP Server
+
+Usage: mysql-mcp [options]
+
+Connection Options:
+  --mysql, -m <url>           MySQL connection string
+                              (mysql://user:pass@host:port/database)
+  --mysql-host <host>         MySQL host (default: localhost)
+  --mysql-port <port>         MySQL port (default: 3306)
+  --mysql-user <user>         MySQL username
+  --mysql-password <pass>     MySQL password
+  --mysql-database <db>       MySQL database name
+
+Pool Options:
+  --pool-size <n>             Connection pool size (default: 10)
+  --pool-timeout <ms>         Connection acquire timeout (default: 10000)
+  --pool-queue-limit <n>      Queue limit for waiting requests (default: 0)
+
+Server Options:
+  --transport, -t <type>      Transport type: stdio, http, sse (default: stdio)
+  --port, -p <port>           HTTP port for http/sse transports
+  --tool-filter, -f <filter>  Tool filter string (e.g., "-replication,-partitioning")
+  --name <name>               Server name (default: mysql-mcp)
+
+OAuth Options:
+  --oauth-enabled, -o         Enable OAuth 2.0 authentication
+  --oauth-issuer <url>        Authorization server URL (issuer)
+  --oauth-audience <aud>      Expected token audience
+  --oauth-jwks-uri <url>      JWKS URI (auto-discovered from issuer if not set)
+  --oauth-clock-tolerance <s> Clock tolerance in seconds (default: 60)
+
+Other:
+  --version, -v               Show version
+  --help, -h                  Show this help
+
+Environment Variables:
+  MYSQL_HOST                  MySQL host
+  MYSQL_PORT                  MySQL port
+  MYSQL_USER                  MySQL username
+  MYSQL_PASSWORD              MySQL password
+  MYSQL_DATABASE              MySQL database
+  MYSQL_POOL_SIZE             Connection pool size
+  MYSQL_MCP_TOOL_FILTER       Tool filter string
+  LOG_LEVEL                   Log level (debug, info, warn, error)
+  OAUTH_ENABLED               Enable OAuth (true/false)
+  OAUTH_ISSUER                Authorization server URL
+  OAUTH_AUDIENCE              Expected token audience
+  OAUTH_JWKS_URI              JWKS endpoint URL
+  OAUTH_CLOCK_TOLERANCE       Clock tolerance in seconds
+`);
+}

package/src/cli.ts

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+/**
+ * mysql-mcp - Command Line Interface
+ * 
+ * Entry point for running the mysql-mcp server from the command line.
+ */
+
+import { createServer } from './server/McpServer.js';
+import { MySQLAdapter } from './adapters/mysql/MySQLAdapter.js';
+import type { McpServerConfig, DatabaseConfig, OAuthConfig } from './types/index.js';
+import { parseArgs } from './cli/args.js';
+import { logger } from './utils/logger.js';
+
+/**
+ * Tool groups that don't require a MySQL database connection.
+ * These tools connect to external services via HTTP/CLI.
+ */
+const MYSQL_OPTIONAL_GROUPS = new Set(['router', 'proxysql', 'shell']);
+
+/**
+ * Check if the tool filter only includes groups that don't need MySQL connection.
+ * Returns true if MySQL connection can be skipped.
+ */
+function canSkipMySQLConnection(toolFilter: string | undefined): boolean {
+    if (!toolFilter) return false;
+    
+    // Parse the filter to extract enabled groups
+    // Format examples: "router", "router,proxysql", "ecosystem", "-core,router"
+    const parts = toolFilter.split(',').map(p => p.trim().toLowerCase());
+    
+    // If using shortcuts that include MySQL-requiring tools, need connection
+    const shortcutsRequiringMySQL = [
+        'starter', 'essential', 'dev-power', 'ai-data', 'ai-spatial',
+        'dba-monitor', 'dba-manage', 'dba-secure', 'base-core', 'base-advanced'
+    ];
+    
+    // Check if any shortcut requiring MySQL is used
+    for (const part of parts) {
+        const cleanPart = part.replace(/^[+-]/, '');
+        if (shortcutsRequiringMySQL.includes(cleanPart)) {
+            return false;
+        }
+    }
+    
+    // Get all positive (included) groups
+    const enabledGroups = new Set<string>();
+    for (const part of parts) {
+        if (part.startsWith('-')) continue; // Skip exclusions
+        const cleanPart = part.replace(/^[+]/, '');
+        
+        // 'ecosystem' shortcut = router + proxysql + shell (no MySQL needed)
+        if (cleanPart === 'ecosystem') {
+            enabledGroups.add('router');
+            enabledGroups.add('proxysql');
+            enabledGroups.add('shell');
+        } else {
+            enabledGroups.add(cleanPart);
+        }
+    }
+    
+    // If no enabled groups found, can't skip
+    if (enabledGroups.size === 0) return false;
+    
+    // Check if ALL enabled groups are MySQL-optional
+    for (const group of enabledGroups) {
+        if (!MYSQL_OPTIONAL_GROUPS.has(group)) {
+            return false;
+        }
+    }
+    
+    return true;
+}
+
+/**
+ * Main entry point
+ */
+export async function main(
+    args?: {
+        config: Partial<McpServerConfig>;
+        databases: DatabaseConfig[];
+        oauth: OAuthConfig | undefined;
+        shouldExit?: boolean;
+    }
+): Promise<void> {
+    const { config, databases, oauth, shouldExit } = args ?? parseArgs();
+
+    if (shouldExit) {
+        process.exit(0);
+    }
+
+    // Check if MySQL connection can be skipped based on tool filter
+    const skipMySQLConnection = canSkipMySQLConnection(config.toolFilter);
+    
+    if (databases.length === 0 && !skipMySQLConnection) {
+        console.error('Error: No database connection specified');
+        console.error('Use --mysql or environment variables to configure connection');
+        console.error('Run with --help for usage information');
+        process.exit(1);
+    }
+
+    // Log OAuth status (without exposing sensitive configuration)
+    if (oauth?.enabled) {
+        console.error('OAuth authentication enabled');
+    }
+
+    // Create server
+    const server = createServer({
+        ...config,
+        databases,
+        oauth
+    });
+
+    // Handle graceful shutdown
+    const shutdown = async (): Promise<never> => {
+        console.error('\nShutting down...');
+        await server.stop();
+        process.exit(0);
+    };
+
+    process.on('SIGINT', () => void shutdown());
+    process.on('SIGTERM', () => void shutdown());
+
+    try {
+        // Create and connect adapters
+        for (const dbConfig of databases) {
+            if (dbConfig.type === 'mysql') {
+                const adapter = new MySQLAdapter();
+                
+                if (skipMySQLConnection) {
+                    // Register adapter without connecting for external-only tools
+                    logger.info('Skipping MySQL connection (not needed for selected tools)', {
+                        toolFilter: config.toolFilter
+                    });
+                    server.registerAdapter(adapter, `mysql:${dbConfig.database ?? 'default'}`);
+                } else {
+                    // Normal flow: connect then register
+                    await adapter.connect(dbConfig);
+                    server.registerAdapter(adapter, `mysql:${dbConfig.database ?? 'default'}`);
+                }
+            }
+        }
+        
+        // If no databases configured but using external-only tools, create a placeholder adapter
+        if (databases.length === 0 && skipMySQLConnection) {
+            logger.info('Running without MySQL connection (external tools only)', {
+                toolFilter: config.toolFilter
+            });
+            const adapter = new MySQLAdapter();
+            server.registerAdapter(adapter, 'mysql:external');
+        }
+
+        // Start server
+        await server.start();
+    } catch (error) {
+        console.error('Fatal error:', error);
+        process.exit(1);
+    }
+}
+
+// Run if called directly
+import { fileURLToPath } from 'url';
+
+// Only run if this file is the main module
+const isMainModule = process.argv[1] === fileURLToPath(import.meta.url);
+
+if (isMainModule) {
+    main().catch(console.error);
+}

package/src/constants/ServerInstructions.ts

@@ -0,0 +1,159 @@
+/**
+ * Server instructions for MySQL MCP.
+ *
+ * These instructions are automatically sent to MCP clients during initialization,
+ * providing guidance for AI agents on tool usage.
+ */
+
+import type { ToolGroup, ResourceDefinition, PromptDefinition } from '../types/index.js';
+import { TOOL_GROUPS } from '../filtering/ToolConstants.js';
+
+/**
+ * Base instructions that are always included
+ */
+const BASE_INSTRUCTIONS = `# mysql-mcp Usage Instructions
+
+## Server Identity
+
+- **Server Name**: This server is identified as \`user-mysql\` in MCP client configurations.
+- **Tool Invocation**: When calling tools via MCP, they are prefixed with the server name (e.g., \`user-mysql-mysql_json_extract\`, \`user-mysql-mysql_read_query\`).
+- **Resources**: 
+  - Resources use the \`mysql://\` URI scheme (e.g., \`mysql://capabilities\`, \`mysql://schema\`).
+  - When listing or fetching resources, use server name \`user-mysql\` (e.g., \`list_mcp_resources(server: "user-mysql")\`, \`fetch_mcp_resource(server: "user-mysql", uri: "mysql://schema")\`).
+
+## JSON Tools (\`mysql_json_*\`)
+
+- **Strict Quoting**: When passing string values to JSON tools, you **must quote the string** if you intend to store it as a JSON string.
+  - ❌ Incorrect: \`value: "green"\` (interpreted as invalid JSON)
+  - ✅ Correct: \`value: "\\"green\\""\` (stored as string "green")
+  - ✅ Correct: \`value: 42\` (stored as number)
+  - ✅ Correct: \`value: {"key": "val"}\` (stored as object)
+- **Validation**: Creating or updating JSON values enforces strict JSON validity checks.
+
+## Transactions & Safety (\`mysql_transaction_*\`)
+
+- Use transactions for multi-step changes:
+  1. Call \`mysql_transaction_begin\` → get \`transactionId\`
+  2. Perform updates with \`transactionId\`
+  3. If successful, \`mysql_transaction_commit\`
+  4. If error, \`mysql_transaction_rollback\`
+
+## Document Store (\`mysql_doc_*\`)
+
+- **Filter Syntax** (for \`mysql_doc_modify\`, \`mysql_doc_remove\`):
+  - **By _id**: Pass the 32-character hex _id directly: \`filter: "686dd247b9724bcfa08ce6f1efed8b77"\`
+  - **By field value**: Use \`field=value\` format: \`filter: "name=Alice"\` or \`filter: "age=30"\`
+  - **By existence**: Use JSON path: \`filter: "$.address"\` (matches docs where address field exists)
+  - ❌ Incorrect: \`filter: "$.name == 'Alice'"\` (comparison operators not supported in path)
+  - ✅ Correct: \`filter: "name=Alice"\` (field=value format)
+- **Find Filters** (\`mysql_doc_find\`): The filter parameter checks for field existence using JSON path (e.g., \`$.address.zip\`).
+
+## Fulltext Search (\`mysql_fulltext_boolean\`)
+
+- Uses MySQL boolean operators: \`+word\` (AND), \`-word\` (NOT), \`word*\` (wildcard), \`> <\` (relevance weighting)
+
+## DDL Statements (\`mysql_write_query\`)
+
+- DDL statements (like \`CREATE TABLE\`) are automatically handled via text protocol fallback.
+
+## Role Management
+
+- Role tools require appropriate privileges.
+- \`mysql_role_grant\` supports \`db.table\` syntax (e.g., \`GRANT SELECT ON my_schema.my_table\`).
+
+## Group Replication (\`mysql_gr_*\`)
+
+- Tools check for \`group_replication\` plugin status and return "not active" if plugin is not active.
+
+## MySQL Router Tools (\`mysql_router_*\`)
+
+- **Prerequisites**: Router REST API requires InnoDB Cluster to be running (authentication uses \`metadata_cache\` backend)
+- **Self-signed certificates**: Set \`MYSQL_ROUTER_INSECURE=true\` to bypass TLS certificate verification for development/testing
+- **Route names**: Use \`mysql_router_routes\` to list available routes (e.g., \`bootstrap_rw\`, \`bootstrap_ro\`)
+- **Metadata cache**: The \`metadataName\` parameter is typically \`bootstrap\` for bootstrapped routers
+
+## Partitioning Tools (\`mysql_partition_*\`, \`mysql_add_partition\`, \`mysql_drop_partition\`, \`mysql_reorganize_partition\`)
+
+- **Value Parameter**: The \`value\` parameter expects only the boundary value, NOT the full SQL clause.
+  - ❌ Incorrect: \`value: "LESS THAN (2024)"\` (SQL syntax error - duplicates keywords)
+  - ✅ Correct: \`value: "2024"\` for RANGE partitions
+  - ✅ Correct: \`value: "1,2,3"\` for LIST partitions
+  - ✅ Correct: \`value: "4"\` for HASH/KEY (number of partitions to add)
+- **Reorganize**: Requires \`partitionType\` parameter (RANGE or LIST). HASH/KEY partitions cannot be reorganized.
+- **Drop Warning**: \`mysql_drop_partition\` permanently deletes all data in the partition.
+
+## Spatial Tools (\`mysql_spatial_*\`)
+
+- **Coordinate Order**: All spatial tools use standard **longitude, latitude** parameter order (X, Y), matching GeoJSON and common mapping conventions.
+  - ✅ Example: \`{ longitude: -122.4194, latitude: 37.7749 }\` for San Francisco
+  - MySQL 8.0+ uses EPSG standard axis order (latitude, longitude) internally for SRID 4326, but tools handle this conversion automatically using \`axis-order=long-lat\` option.
+- **SRID 4326**: Default spatial reference system is WGS 84 (GPS coordinates). Use \`srid\` parameter to specify other coordinate systems.
+`;
+
+/**
+ * Generate dynamic instructions based on enabled tools, resources, and prompts
+ */
+export function generateInstructions(
+    enabledTools: Set<string>,
+    resources: ResourceDefinition[],
+    prompts: PromptDefinition[]
+): string {
+    let instructions = BASE_INSTRUCTIONS;
+
+    // Add active tools section
+    const activeGroups = getActiveToolGroups(enabledTools);
+    if (activeGroups.length > 0) {
+        instructions += '\n## Active Tools\n\n';
+        instructions += `This server instance has ${enabledTools.size} tools enabled across ${activeGroups.length} groups:\n\n`;
+        
+        for (const { group, tools } of activeGroups) {
+            instructions += `### ${group} (${tools.length} tools)\n`;
+            instructions += tools.map(t => `- \`${t}\``).join('\n');
+            instructions += '\n\n';
+        }
+    }
+
+    // Add resources section
+    if (resources.length > 0) {
+        instructions += `## Active Resources (${resources.length})\n\n`;
+        instructions += 'Read-only resources for database metadata:\n\n';
+        for (const resource of resources) {
+            instructions += `- \`${resource.uri}\` - ${resource.description}\n`;
+        }
+        instructions += '\n';
+    }
+
+    // Add prompts section
+    if (prompts.length > 0) {
+        instructions += `## Active Prompts (${prompts.length})\n\n`;
+        instructions += 'Pre-built query templates and guided workflows:\n\n';
+        for (const prompt of prompts) {
+            instructions += `- \`${prompt.name}\` - ${prompt.description}\n`;
+        }
+        instructions += '\n';
+    }
+
+    return instructions;
+}
+
+/**
+ * Get active tool groups with their enabled tools
+ */
+function getActiveToolGroups(enabledTools: Set<string>): { group: ToolGroup; tools: string[] }[] {
+    const activeGroups: { group: ToolGroup; tools: string[] }[] = [];
+    
+    for (const [group, allTools] of Object.entries(TOOL_GROUPS) as [ToolGroup, string[]][]) {
+        const enabledInGroup = allTools.filter(tool => enabledTools.has(tool));
+        if (enabledInGroup.length > 0) {
+            activeGroups.push({ group, tools: enabledInGroup });
+        }
+    }
+    
+    return activeGroups;
+}
+
+/**
+ * Static instructions for backward compatibility
+ * @deprecated Use generateInstructions() instead for dynamic content
+ */
+export const SERVER_INSTRUCTIONS = BASE_INSTRUCTIONS;