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

/**
 * list_edge_function_logs - Lists execution logs for edge functions.
 *
 * Queries the function_edge_logs table if available in the Supabase instance.
 * This table is automatically created by Supabase for edge function logging.
 */

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

const EdgeFunctionLogSchema = z.object({
    execution_id: z.string().nullable(),
    function_id: z.string(),
    status_code: z.number().nullable(),
    request_start_time: z.string(),
    request_duration_ms: z.number().nullable(),
    error_message: z.string().nullable(),
    request_path: z.string().nullable(),
    request_method: z.string().nullable(),
});

const ListEdgeFunctionLogsOutputSchema = z.array(EdgeFunctionLogSchema);

const ListEdgeFunctionLogsInputSchema = z.object({
    function_id: z.string().optional().describe('Filter by function ID/slug.'),
    status_code: z.number().optional().describe('Filter by HTTP status code.'),
    errors_only: z.boolean().optional().describe('Only show logs with errors (status >= 400).'),
    limit: z.number().optional().default(100).describe('Maximum number of log entries to return.'),
});

type ListEdgeFunctionLogsInput = z.infer<typeof ListEdgeFunctionLogsInputSchema>;

const mcpInputSchema = {
    type: 'object',
    properties: {
        function_id: {
            type: 'string',
            description: 'Filter by function ID/slug.',
        },
        status_code: {
            type: 'number',
            description: 'Filter by HTTP status code.',
        },
        errors_only: {
            type: 'boolean',
            description: 'Only show logs with errors (status >= 400).',
        },
        limit: {
            type: 'number',
            description: 'Maximum number of log entries to return.',
            default: 100,
        },
    },
    required: [],
};

// Pattern for function IDs (UUIDs or slugs)
const functionIdPattern = /^[a-zA-Z0-9_\-]+$/;

export const listEdgeFunctionLogsTool = {
    name: 'list_edge_function_logs',
    description: 'Lists execution logs for edge functions from the function_edge_logs table.',
    privilegeLevel: 'regular' as ToolPrivilegeLevel,
    inputSchema: ListEdgeFunctionLogsInputSchema,
    mcpInputSchema: mcpInputSchema,
    outputSchema: ListEdgeFunctionLogsOutputSchema,

    execute: async (input: ListEdgeFunctionLogsInput, context: ToolContext) => {
        const client = context.selfhostedClient;
        const { function_id, status_code, errors_only, limit = 100 } = input;

        // Validate function_id if provided
        if (function_id && !functionIdPattern.test(function_id)) {
            throw new Error(`Invalid function ID: ${function_id}. Use only alphanumeric, underscore, and hyphen characters.`);
        }

        // Check if function_edge_logs table exists
        const checkTableSql = `
            SELECT EXISTS (
                SELECT 1
                FROM information_schema.tables
                WHERE table_name = 'function_edge_logs'
            ) as exists;
        `;

        const tableCheck = await executeSqlWithFallback(client, checkTableSql, true);

        if (!Array.isArray(tableCheck) || tableCheck.length === 0) {
            throw new Error('Failed to check for function_edge_logs table.');
        }

        if (!tableCheck[0].exists) {
            throw new Error(
                'Edge function logs table (function_edge_logs) not found. ' +
                'This table is automatically created by Supabase when edge functions are invoked. ' +
                'Ensure edge functions have been executed at least once.'
            );
        }

        // Build query with filters
        const conditions: string[] = [];

        if (function_id) {
            conditions.push(`function_id = '${function_id}'`);
        }

        if (status_code !== undefined) {
            // status_code is a number from Zod validation, safe to use directly
            conditions.push(`status_code = ${status_code}`);
        }

        if (errors_only) {
            conditions.push('status_code >= 400');
        }

        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';

        // Ensure limit is within bounds
        const safeLimit = Math.min(Math.max(1, limit), 1000);

        const logsSql = `
            SELECT
                execution_id::text,
                function_id,
                status_code,
                request_start_time::text,
                EXTRACT(EPOCH FROM (request_end_time - request_start_time)) * 1000 as request_duration_ms,
                error_message,
                request_path,
                request_method
            FROM function_edge_logs
            ${whereClause}
            ORDER BY request_start_time DESC
            LIMIT ${safeLimit}
        `;

        const result = await executeSqlWithFallback(client, logsSql, true);
        return handleSqlResponse(result, ListEdgeFunctionLogsOutputSchema);
    },
};