@aliyun-rds/supabase-mcp-server 1.0.8 → 1.0.10

package/dist/index.js

@@ -398,6 +398,58 @@ function getAuthModeDescription(mode) {
   }
 }
 
+// src/sql/execute_sql_function.ts
+var DROP_OLD_EXECUTE_SQL_FUNCTIONS = `
+DO $$
+BEGIN
+    -- Drop all previous versions to avoid overload conflicts
+    DROP FUNCTION IF EXISTS public.execute_sql(text, boolean);
+    DROP FUNCTION IF EXISTS public.execute_sql(text);
+END $$;
+`;
+var CREATE_EXECUTE_SQL_FUNCTION = `
+CREATE OR REPLACE FUNCTION public.execute_sql(query text)
+RETURNS jsonb
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = public
+AS $$
+DECLARE
+    result jsonb;
+    cleaned_query text;
+    affected_rows integer;
+    is_read_query boolean;
+BEGIN
+    -- Remove trailing semicolons and whitespace from query
+    cleaned_query := regexp_replace(trim(query), ';\\s*$', '');
+
+    -- Auto-detect: treat as read query if starts with SELECT/WITH/SHOW/EXPLAIN/DESCRIBE/TABLE
+    is_read_query := cleaned_query ~* '^[[:space:]]*(SELECT|WITH|SHOW|EXPLAIN|DESCRIBE|TABLE)';
+
+    IF is_read_query THEN
+        -- Read query: return results as JSON array
+        EXECUTE 'SELECT COALESCE(jsonb_agg(row_to_json(t)), ''[]''::jsonb) FROM (' || cleaned_query || ') t' INTO result;
+    ELSE
+        -- Write query (INSERT/UPDATE/DELETE): execute and return affected rows count
+        EXECUTE cleaned_query;
+        GET DIAGNOSTICS affected_rows = ROW_COUNT;
+        result := jsonb_build_array(jsonb_build_object('affected_rows', affected_rows));
+    END IF;
+
+    RETURN COALESCE(result, '[]'::jsonb);
+EXCEPTION
+    WHEN OTHERS THEN
+        RAISE EXCEPTION 'Error executing SQL (SQLSTATE: %): %', SQLSTATE, SQLERRM;
+END;
+$$;
+`;
+var GRANT_EXECUTE_SQL_FUNCTION = `
+-- SECURITY: do NOT expose arbitrary SQL execution to anon/authenticated roles.
+REVOKE EXECUTE ON FUNCTION public.execute_sql(text) FROM PUBLIC;
+GRANT EXECUTE ON FUNCTION public.execute_sql(text) TO service_role;
+`;
+var NOTIFY_POSTGREST = `NOTIFY pgrst, 'reload schema';`;
+
 // src/client/index.ts
 var SelfhostedSupabaseClient = class _SelfhostedSupabaseClient {
   options;
@@ -409,35 +461,6 @@ var SelfhostedSupabaseClient = class _SelfhostedSupabaseClient {
   authMode;
   /** User authentication client (only set for AuthMode.SINGLE_INSTANCE_USER) */
   userAuthClient = null;
-  // SQL definition for the helper function
-  static CREATE_EXECUTE_SQL_FUNCTION = `
-        CREATE OR REPLACE FUNCTION public.execute_sql(query text, read_only boolean DEFAULT false)
-        RETURNS jsonb -- Using jsonb is generally preferred over json
-        LANGUAGE plpgsql
-        AS $$
-        DECLARE
-          result jsonb;
-        BEGIN
-          -- Note: SET TRANSACTION READ ONLY might not behave as expected within a function
-          -- depending on the outer transaction state. Handle read-only logic outside if needed.
-
-          -- Execute the dynamic query and aggregate results into a JSONB array
-          EXECUTE 'SELECT COALESCE(jsonb_agg(t), ''[]''::jsonb) FROM (' || query || ') t' INTO result;
-
-          RETURN result;
-        EXCEPTION
-          WHEN others THEN
-            -- Rethrow the error with context, including the original SQLSTATE
-            RAISE EXCEPTION 'Error executing SQL (SQLSTATE: %): % ', SQLSTATE, SQLERRM;
-        END;
-        $$;
-    `;
-  // SQL to grant permissions
-  static GRANT_EXECUTE_SQL_FUNCTION = `
-        GRANT EXECUTE ON FUNCTION public.execute_sql(text, boolean) TO authenticated;
-        -- Optionally grant to anon if needed (uncomment if required):
-        -- GRANT EXECUTE ON FUNCTION public.execute_sql(text, boolean) TO anon;
-    `;
   /**
    * Creates an instance of SelfhostedSupabaseClient.
    * Note: Call initialize() after creating the instance to check for RPC functions.
@@ -502,8 +525,7 @@ var SelfhostedSupabaseClient = class _SelfhostedSupabaseClient {
     console.error("Initializing SelfhostedSupabaseClient for user-level authentication...");
     try {
       const { error } = await this.supabase.rpc("execute_sql", {
-        query: "SELECT 1",
-        read_only: true
+        query: "SELECT 1"
       });
       this.rpcFunctionExists = !error;
       if (error) {
@@ -535,7 +557,7 @@ var SelfhostedSupabaseClient = class _SelfhostedSupabaseClient {
   /**
    * Executes SQL using the preferred RPC method.
    */
-  async executeSqlViaRpc(query, readOnly = false) {
+  async executeSqlViaRpc(query) {
     if (!this.rpcFunctionExists) {
       console.error("Attempted to call executeSqlViaRpc, but RPC function is not available.");
       return {
@@ -545,12 +567,9 @@ var SelfhostedSupabaseClient = class _SelfhostedSupabaseClient {
         }
       };
     }
-    console.error(`Executing via RPC (readOnly: ${readOnly}): ${query.substring(0, 100)}...`);
+    console.error(`Executing via RPC: ${query.substring(0, 100)}...`);
     try {
-      const { data, error } = await this.supabase.rpc("execute_sql", {
-        query,
-        read_only: readOnly
-      });
+      const { data, error } = await this.supabase.rpc("execute_sql", { query });
       if (error) {
         console.error("Error executing SQL via RPC:", error);
         return {
@@ -730,22 +749,30 @@ var SelfhostedSupabaseClient = class _SelfhostedSupabaseClient {
                     JOIN pg_namespace n ON p.pronamespace = n.oid
                     WHERE n.nspname = 'public'
                     AND p.proname = 'execute_sql'
+                    AND p.pronargs = 1
                 ) as function_exists;
             `;
       const checkResult = await this.executeSqlViaPostgresMeta(checkQuery);
-      if (checkResult && checkResult.length > 0 && checkResult[0].function_exists) {
-        console.error("'public.execute_sql' function found.");
-        this.rpcFunctionExists = true;
-        return;
+      if (checkResult && checkResult.length > 0 && checkResult[0]?.function_exists) {
+        console.error("'public.execute_sql' function found. Enforcing least-privilege grants...");
+        try {
+          await this.executeSqlViaPostgresMeta(GRANT_EXECUTE_SQL_FUNCTION);
+          this.rpcFunctionExists = true;
+          return;
+        } catch (grantError) {
+          console.error("Failed to enforce grants for execute_sql. Will recreate the function to ensure a clean state:", grantError);
+        }
       }
       console.error("'public.execute_sql' function not found. Creating...");
       try {
+        console.error("Dropping old function versions...");
+        await this.executeSqlViaPostgresMeta(DROP_OLD_EXECUTE_SQL_FUNCTIONS);
         console.error("Creating 'public.execute_sql' function using postgres-meta API...");
-        await this.executeSqlViaPostgresMeta(_SelfhostedSupabaseClient.CREATE_EXECUTE_SQL_FUNCTION);
-        await this.executeSqlViaPostgresMeta(_SelfhostedSupabaseClient.GRANT_EXECUTE_SQL_FUNCTION);
+        await this.executeSqlViaPostgresMeta(CREATE_EXECUTE_SQL_FUNCTION);
+        await this.executeSqlViaPostgresMeta(GRANT_EXECUTE_SQL_FUNCTION);
         console.error("'public.execute_sql' function created and permissions granted successfully.");
         console.error("Notifying PostgREST to reload schema cache...");
-        await this.executeSqlViaPostgresMeta("NOTIFY pgrst, 'reload schema'");
+        await this.executeSqlViaPostgresMeta(NOTIFY_POSTGREST);
         console.error("PostgREST schema reload notification sent.");
         this.rpcFunctionExists = true;
       } catch (postgresMetaError) {
@@ -753,9 +780,10 @@ var SelfhostedSupabaseClient = class _SelfhostedSupabaseClient {
         if (this.options.databaseUrl) {
           try {
             console.error("Falling back to direct DB connection...");
-            await this.executeSqlWithPg(_SelfhostedSupabaseClient.CREATE_EXECUTE_SQL_FUNCTION);
-            await this.executeSqlWithPg(_SelfhostedSupabaseClient.GRANT_EXECUTE_SQL_FUNCTION);
-            await this.executeSqlWithPg("NOTIFY pgrst, 'reload schema'");
+            await this.executeSqlWithPg(DROP_OLD_EXECUTE_SQL_FUNCTIONS);
+            await this.executeSqlWithPg(CREATE_EXECUTE_SQL_FUNCTION);
+            await this.executeSqlWithPg(GRANT_EXECUTE_SQL_FUNCTION);
+            await this.executeSqlWithPg(NOTIFY_POSTGREST);
             console.error("'public.execute_sql' function created via direct DB connection.");
             this.rpcFunctionExists = true;
           } catch (pgError) {
@@ -872,6 +900,32 @@ import { z } from "zod";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 var execAsync = promisify(exec);
+async function execPostgresMetaQuery(postgresMetaUrl, apiKey, query, action) {
+  const response = await fetch(postgresMetaUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "apikey": apiKey
+    },
+    body: JSON.stringify({ query })
+  });
+  const responseText = await response.text().catch(() => "");
+  if (!response.ok) {
+    throw new Error(`${action} failed (${response.status}): ${responseText || response.statusText}`);
+  }
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json") && responseText) {
+    let parsed;
+    try {
+      parsed = JSON.parse(responseText);
+    } catch {
+      parsed = void 0;
+    }
+    if (parsed && typeof parsed === "object" && "error" in parsed) {
+      throw new Error(`${action} failed: ${responseText}`);
+    }
+  }
+}
 function isSqlErrorResponse(result) {
   return result.error !== void 0;
 }
@@ -902,13 +956,77 @@ async function runExternalCommand(command) {
     };
   }
 }
-async function executeSqlWithFallback(client, sql, readOnly = true) {
+async function tryInstallRpcFunction(client) {
+  console.warn("Attempting to auto-install execute_sql RPC function...");
+  try {
+    const supabaseUrl = client.getSupabaseUrl();
+    const serviceKey = client.getServiceRoleKey();
+    if (!serviceKey) {
+      console.error("Auto-install failed: Service role key not available");
+      return false;
+    }
+    const postgresMetaUrl = `${supabaseUrl}/pg/query`;
+    console.warn("Dropping old function versions...");
+    await execPostgresMetaQuery(
+      postgresMetaUrl,
+      serviceKey,
+      DROP_OLD_EXECUTE_SQL_FUNCTIONS,
+      "Dropping old function versions"
+    );
+    await execPostgresMetaQuery(
+      postgresMetaUrl,
+      serviceKey,
+      CREATE_EXECUTE_SQL_FUNCTION,
+      "Creating execute_sql function"
+    );
+    await execPostgresMetaQuery(
+      postgresMetaUrl,
+      serviceKey,
+      GRANT_EXECUTE_SQL_FUNCTION,
+      "Granting execute_sql permissions"
+    );
+    try {
+      await execPostgresMetaQuery(
+        postgresMetaUrl,
+        serviceKey,
+        NOTIFY_POSTGREST,
+        "Notifying PostgREST to reload schema"
+      );
+    } catch (notifyError) {
+      console.error("Warning: Failed to notify PostgREST to reload schema. You may need to restart PostgREST or wait a few seconds:", notifyError);
+    }
+    client.setRpcAvailable(true);
+    console.warn("Auto-install succeeded! RPC function is now available.");
+    return true;
+  } catch (error) {
+    console.error("Auto-install failed with exception:", error);
+    console.error("Note: The function may have been partially created. Try running install_execute_sql_function manually, or restart PostgREST, then retry.");
+    return false;
+  }
+}
+async function executeSqlWithFallback(client, sql) {
   if (client.isPgAvailable()) {
-    console.info("Using direct database connection (bypassing JWT)...");
+    console.warn("Using direct database connection (bypassing JWT)...");
     return await client.executeSqlWithPg(sql);
   }
-  console.info("Falling back to RPC method...");
-  return await client.executeSqlViaRpc(sql, readOnly);
+  console.warn("Falling back to RPC method...");
+  const result = await client.executeSqlViaRpc(sql);
+  if (isSqlErrorResponse(result) && result.error.code === "MCP_CLIENT_ERROR" && result.error.message.includes("RPC function not found")) {
+    console.warn("RPC function not found. Attempting auto-install and retry...");
+    const installed = await tryInstallRpcFunction(client);
+    if (installed) {
+      await new Promise((resolve3) => setTimeout(resolve3, 1e3));
+      console.warn("Retrying SQL execution after auto-install...");
+      return await client.executeSqlViaRpc(sql);
+    }
+    return {
+      error: {
+        code: "MCP_CLIENT_ERROR",
+        message: "execute_sql RPC function not found. Auto-install failed. Please run install_execute_sql_function tool manually, or restart PostgREST, or configure DATABASE_URL for direct connection."
+      }
+    };
+  }
+  return result;
 }
 
 // src/tools/list_tables.ts
@@ -1113,17 +1231,13 @@ var applyMigrationTool = {
 // src/tools/execute_sql.ts
 import { z as z6 } from "zod";
 var ExecuteSqlInputSchema = z6.object({
-  sql: z6.string().describe("The SQL query to execute."),
-  read_only: z6.boolean().optional().default(false).describe("Hint for the RPC function whether the query is read-only (best effort).")
-  // Future enhancement: Add option to force direct connection?
-  // use_direct_connection: z.boolean().optional().default(false).describe('Attempt to use direct DB connection instead of RPC.'),
+  sql: z6.string().describe("The SQL query to execute.")
 });
 var ExecuteSqlOutputSchema = z6.array(z6.unknown()).describe("The array of rows returned by the SQL query.");
 var mcpInputSchema5 = {
   type: "object",
   properties: {
-    sql: { type: "string", description: "The SQL query to execute." },
-    read_only: { type: "boolean", default: false, description: "Hint for the RPC function whether the query is read-only (best effort)." }
+    sql: { type: "string", description: "The SQL query to execute." }
   },
   required: ["sql"]
 };
@@ -1135,8 +1249,8 @@ var executeSqlTool = {
   outputSchema: ExecuteSqlOutputSchema,
   execute: async (input, context) => {
     const client = context.selfhostedClient;
-    console.error(`Executing SQL (readOnly: ${input.read_only}): ${input.sql.substring(0, 100)}...`);
-    const result = await executeSqlWithFallback(client, input.sql, input.read_only);
+    console.error(`Executing SQL: ${input.sql.substring(0, 100)}...`);
+    const result = await executeSqlWithFallback(client, input.sql);
     return handleSqlResponse(result, ExecuteSqlOutputSchema);
   }
 };
@@ -2255,42 +2369,6 @@ var InstallExecuteSqlFunctionOutputZodSchema = z23.object({
   success: z23.boolean(),
   message: z23.string()
 });
-var CREATE_EXECUTE_SQL_FUNCTION = `
-CREATE OR REPLACE FUNCTION public.execute_sql(query text, read_only boolean DEFAULT true)
-RETURNS jsonb
-LANGUAGE plpgsql
-SECURITY DEFINER
-SET search_path = public
-AS $$
-DECLARE
-    result jsonb;
-    cleaned_query text;
-BEGIN
-    -- Remove trailing semicolons and whitespace from query
-    cleaned_query := regexp_replace(trim(query), ';\\s*$', '');
-    
-    -- Execute query and convert result to JSON
-    IF read_only THEN
-        -- Read-only query
-        EXECUTE 'SELECT COALESCE(jsonb_agg(row_to_json(t)), ''[]''::jsonb) FROM (' || cleaned_query || ') t' INTO result;
-    ELSE
-        -- Write query (INSERT/UPDATE/DELETE)
-        EXECUTE cleaned_query;
-        result := '[]'::jsonb;
-    END IF;
-    
-    RETURN COALESCE(result, '[]'::jsonb);
-EXCEPTION
-    WHEN OTHERS THEN
-        -- Return error information
-        RAISE EXCEPTION 'Error executing SQL (SQLSTATE: %): %', SQLSTATE, SQLERRM;
-END;
-$$;
-`;
-var GRANT_EXECUTE_SQL_FUNCTION = `
-GRANT EXECUTE ON FUNCTION public.execute_sql(text, boolean) TO anon, authenticated, service_role;
-`;
-var NOTIFY_POSTGREST = `NOTIFY pgrst, 'reload schema';`;
 async function execute(input, context) {
   const client = context.selfhostedClient;
   context.log("Installing execute_sql RPC function...", "info");
@@ -2301,6 +2379,15 @@ async function execute(input, context) {
       throw new Error("Service role key is required to install the execute_sql function");
     }
     const postgresMetaUrl = `${supabaseUrl}/pg/query`;
+    context.log("Dropping old function versions...", "info");
+    await fetch(postgresMetaUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "apikey": serviceKey
+      },
+      body: JSON.stringify({ query: DROP_OLD_EXECUTE_SQL_FUNCTIONS })
+    });
     context.log("Creating execute_sql function...", "info");
     const createResponse = await fetch(postgresMetaUrl, {
       method: "POST",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliyun-rds/supabase-mcp-server",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "MCP (Model Context Protocol) server for self-hosted Supabase instances. Allows AI assistants to interact with your self-hosted Supabase database.",
   "main": "dist/index.js",
   "bin": {
@@ -34,7 +34,6 @@
   "dependencies": {
     "@alicloud/openapi-client": "^0.4.12",
     "@alicloud/rdsai20250507": "^1.0.0",
-    "@aliyun-rds/supabase-mcp-server": "^1.0.7",
     "@modelcontextprotocol/sdk": "latest",
     "@supabase/supabase-js": "^2.49.4",
     "commander": "^13.1.0",