Self-Hosted Supabase MCP Server

Instructions

Implementation Reference

• src/tools/generate_typescript_types.ts:71-167 (handler)

  The execute function that implements the core logic of the tool: retrieves DB URL, constructs and runs the 'supabase gen types' CLI command, normalizes the output path for cross-platform compatibility, ensures directory exists, writes the generated types to file, and returns structured output with success status and platform info.
  execute: async (input: GenerateTypesInput, context: ToolContext) => { const client = context.selfhostedClient; const dbUrl = client.getDbUrl(); // Need this getter in the client if (!dbUrl) { return { success: false, message: 'Error: DATABASE_URL is not configured. Cannot generate types.', platform: process.platform, }; } // Construct the command // Use --local flag for self-hosted? const schemas = input.included_schemas.join(','); // Comma-separated for the CLI flag // Note: The actual command might vary slightly based on Supabase CLI version and context. // Using --db-url is generally safer for self-hosted. const command = `supabase gen types typescript --db-url "${dbUrl}" --schema "${schemas}"`; console.error(`Running command: ${command}`); try { const { stdout, stderr, error } = await runExternalCommand(command); if (error) { console.error(`Error executing supabase gen types: ${stderr || error.message}`); return { success: false, message: `Command failed: ${stderr || error.message}`, platform: process.platform, }; } if (stderr) { console.error(`supabase gen types produced stderr output: ${stderr}`); // Treat stderr as non-fatal for now, maybe just warnings } // Normalize and save the generated types to the specified absolute path let outputPath: string; try { outputPath = normalizeOutputPath(input.output_path); console.error(`Normalized output path: ${outputPath}`); } catch (pathError) { const pathErrorMessage = pathError instanceof Error ? pathError.message : String(pathError); console.error(`Invalid output path: ${pathErrorMessage}`); return { success: false, message: `Invalid output path "${input.output_path}": ${pathErrorMessage}`, platform: process.platform, }; } try { // Ensure the directory exists const outputDir = dirname(outputPath); try { mkdirSync(outputDir, { recursive: true }); } catch (dirError) { // Ignore error if directory already exists if ((dirError as NodeJS.ErrnoException).code !== 'EEXIST') { throw dirError; } } writeFileSync(outputPath, stdout, 'utf8'); console.error(`Types saved to: ${outputPath}`); } catch (writeError) { const writeErrorMessage = writeError instanceof Error ? writeError.message : String(writeError); console.error(`Failed to write types file: ${writeErrorMessage}`); return { success: false, message: `Type generation succeeded but failed to save file: ${writeErrorMessage}. Platform: ${process.platform}. Attempted path: ${outputPath}`, types: stdout, platform: process.platform, }; } console.error('Type generation and file save successful.'); return { success: true, message: `Types generated successfully and saved to ${outputPath}.${stderr ? `\nWarnings:\n${stderr}` : ''}`, types: stdout, file_path: outputPath, platform: process.platform, }; } catch (err: unknown) { const errorMessage = err instanceof Error ? err.message : String(err); console.error(`Exception during type generation: ${errorMessage}`); return { success: false, message: `Exception during type generation: ${errorMessage}. Platform: ${process.platform}`, platform: process.platform, }; } },
• src/tools/generate_typescript_types.ts:24-62 (schema)

  Zod input and output schemas, plus static JSON mcpInputSchema for MCP tool capabilities, defining parameters like included_schemas, output_filename/path, and response fields.
  // Input schema const GenerateTypesInputSchema = z.object({ included_schemas: z.array(z.string()).optional().default(['public']).describe('Database schemas to include in type generation.'), output_filename: z.string().optional().default('database.types.ts').describe('Filename to save the generated types to in the workspace root.'), output_path: z.string().describe('Absolute path where to save the file. If provided, output_filename will be ignored.'), }); type GenerateTypesInput = z.infer<typeof GenerateTypesInputSchema>; // Output schema const GenerateTypesOutputSchema = z.object({ success: z.boolean(), message: z.string().describe('Output message from the generation process.'), types: z.string().optional().describe('The generated TypeScript types, if successful.'), file_path: z.string().optional().describe('The absolute path to the saved types file, if successful.'), platform: z.string().describe('Operating system platform (win32, darwin, linux).'), }); // Static JSON Schema for MCP capabilities const mcpInputSchema = { type: 'object', properties: { included_schemas: { type: 'array', items: { type: 'string' }, default: ['public'], description: 'Database schemas to include in type generation.', }, output_filename: { type: 'string', default: 'database.types.ts', description: 'Filename to save the generated types to in the workspace root.', }, output_path: { type: 'string', description: 'Absolute path where to download the generated TypeScript file. Examples: Windows: "C:\\\\path\\\\to\\\\project\\\\database.types.ts", macOS/Linux: "/path/to/project/database.types.ts". This parameter is required.', }, }, required: ['output_path'], // output_path is required for file download };
• src/index.ts:110-110 (registration)

  Registration of the generateTypesTool in the availableTools object, which is used to populate server capabilities and handle tool calls in the MCP server.
  [generateTypesTool.name]: generateTypesTool as AppTool,
• src/index.ts:21-21 (registration)

  Import of the generateTypesTool from its implementation file.
  import { generateTypesTool } from './tools/generate_typescript_types.js';
• src/tools/generate_typescript_types.ts:13-22 (helper)

  Helper function to normalize output paths, handling Windows-specific path formats and using Node.js resolve for final normalization.
  function normalizeOutputPath(inputPath: string): string { // Handle Windows drive letters in Unix-style paths (e.g., "/c:/path" -> "C:/path") if (process.platform === 'win32' && inputPath.match(/^\/[a-zA-Z]:/)) { inputPath = inputPath.substring(1); // Remove leading slash inputPath = inputPath.charAt(0).toUpperCase() + inputPath.slice(1); // Uppercase drive letter } // Use Node.js resolve to normalize the path return resolve(inputPath); }