supabase/selfhosted-supabase-mcp/src/tools/get_storage_config.ts

import { z } from 'zod';
import { handleSqlResponse, executeSqlWithFallback } from './utils.js';
import type { ToolContext } from './types.js';

// Schema for bucket configuration
const BucketConfigSchema = z.object({
    id: z.string(),
    name: z.string(),
    public: z.boolean(),
    file_size_limit: z.number().nullable(),
    allowed_mime_types: z.array(z.string()).nullable(),
    avif_autodetection: z.boolean().nullable(),
    owner: z.string().nullable(),
    created_at: z.string().nullable(),
    updated_at: z.string().nullable(),
});

// Schema for output
const GetStorageConfigOutputSchema = z.object({
    buckets: z.array(BucketConfigSchema),
    global_config: z.object({
        max_file_size_limit: z.number().nullable(),
        bucket_count: z.number(),
    }),
});
type GetStorageConfigOutput = z.infer<typeof GetStorageConfigOutputSchema>;

// Input schema
const GetStorageConfigInputSchema = z.object({
    bucket_id: z.string().optional().describe('Optional bucket ID to get config for a specific bucket. If omitted, returns all buckets.'),
});
type GetStorageConfigInput = z.infer<typeof GetStorageConfigInputSchema>;

// Static JSON Schema for MCP capabilities
const mcpInputSchema = {
    type: 'object',
    properties: {
        bucket_id: {
            type: 'string',
            description: 'Optional bucket ID to get config for a specific bucket. If omitted, returns all buckets.',
        },
    },
    required: [],
};

// Tool definition
export const getStorageConfigTool = {
    name: 'get_storage_config',
    description: 'Gets storage configuration for Supabase Storage buckets. Returns bucket settings including file size limits, allowed MIME types, and public/private status.',
    inputSchema: GetStorageConfigInputSchema,
    mcpInputSchema: mcpInputSchema,
    outputSchema: GetStorageConfigOutputSchema,
    execute: async (input: GetStorageConfigInput, context: ToolContext): Promise<GetStorageConfigOutput> => {
        const client = context.selfhostedClient;
        const { bucket_id } = input;

        // Check if storage schema exists
        const checkSchemaSql = `
            SELECT EXISTS (
                SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = 'storage'
            ) AS exists
        `;

        const schemaCheckResult = await executeSqlWithFallback(client, checkSchemaSql, true);

        if (!Array.isArray(schemaCheckResult) || schemaCheckResult.length === 0 || !schemaCheckResult[0]?.exists) {
            context.log('storage schema not found - Storage may not be configured', 'info');
            return {
                buckets: [],
                global_config: {
                    max_file_size_limit: null,
                    bucket_count: 0,
                },
            };
        }

        // Build query for buckets
        let bucketQuery = `
            SELECT
                id,
                name,
                public,
                file_size_limit,
                allowed_mime_types,
                avif_autodetection,
                owner::text,
                created_at::text,
                updated_at::text
            FROM storage.buckets
        `;

        if (bucket_id) {
            // Escape single quotes
            const escapedBucketId = bucket_id.replace(/'/g, "''");
            bucketQuery += ` WHERE id = '${escapedBucketId}'`;
        }

        bucketQuery += ' ORDER BY name';

        const bucketsResult = await executeSqlWithFallback(client, bucketQuery, true);

        const bucketsSchema = z.array(
            z.object({
                id: z.string(),
                name: z.string(),
                public: z.boolean(),
                file_size_limit: z.number().nullable(),
                allowed_mime_types: z.array(z.string()).nullable(),
                avif_autodetection: z.boolean().nullable(),
                owner: z.string().nullable(),
                created_at: z.string().nullable(),
                updated_at: z.string().nullable(),
            })
        );

        const buckets = handleSqlResponse(bucketsResult, bucketsSchema);

        // Get global stats
        const statsQuery = `
            SELECT
                MAX(file_size_limit) as max_file_size_limit,
                COUNT(*) as bucket_count
            FROM storage.buckets
        `;

        const statsResult = await executeSqlWithFallback(client, statsQuery, true);

        let globalConfig = {
            max_file_size_limit: null as number | null,
            bucket_count: buckets.length,
        };

        if (Array.isArray(statsResult) && statsResult.length > 0) {
            const maxLimit = statsResult[0]?.max_file_size_limit;
            globalConfig = {
                max_file_size_limit: typeof maxLimit === 'number' ? maxLimit : null,
                bucket_count: Number(statsResult[0]?.bucket_count) || 0,
            };
        }

        return {
            buckets,
            global_config: globalConfig,
        };
    },
};