chore: import upstream snapshot with attribution

apps/sim/tools/supabase/storage_update_bucket.ts

@@ -0,0 +1,170 @@
+import { getErrorMessage } from '@sim/utils/errors'
+import {
+  STORAGE_MESSAGE_OUTPUT_PROPERTIES,
+  type SupabaseStorageUpdateBucketParams,
+  type SupabaseStorageUpdateBucketResponse,
+} from '@/tools/supabase/types'
+import { encodeStorageSegment, supabaseBaseUrl } from '@/tools/supabase/utils'
+import type { ToolConfig } from '@/tools/types'
+
+export const storageUpdateBucketTool: ToolConfig<
+  SupabaseStorageUpdateBucketParams,
+  SupabaseStorageUpdateBucketResponse
+> = {
+  id: 'supabase_storage_update_bucket',
+  name: 'Supabase Storage Update Bucket',
+  description: 'Update the configuration of an existing Supabase storage bucket',
+  version: '1.0.0',
+
+  params: {
+    projectId: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Your Supabase project ID (e.g., jdrkgepadsdopsntdlom)',
+    },
+    bucket: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'The name of the bucket to update',
+    },
+    isPublic: {
+      type: 'boolean',
+      required: false,
+      visibility: 'user-or-llm',
+      description:
+        'Whether the bucket should be publicly accessible (leave unset to keep the current value)',
+    },
+    fileSizeLimit: {
+      type: 'number',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Maximum file size in bytes (leave unset to keep the current value)',
+    },
+    allowedMimeTypes: {
+      type: 'array',
+      required: false,
+      visibility: 'user-or-llm',
+      description:
+        'Array of allowed MIME types (e.g., ["image/png", "image/jpeg"]) — leave unset to keep the current value',
+    },
+    apiKey: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Your Supabase service role secret key',
+    },
+  },
+
+  /**
+   * Unreachable: `directExecution` below always handles this tool because
+   * the update must first read the bucket's current configuration (the
+   * Storage API's update-bucket endpoint is a full-replace PUT, not a
+   * partial patch). Declared only to satisfy `ToolConfig`'s required
+   * `request` field.
+   */
+  request: {
+    url: (params) =>
+      `${supabaseBaseUrl(params.projectId)}/storage/v1/bucket/${encodeStorageSegment(params.bucket)}`,
+    method: 'PUT',
+    headers: (params) => ({
+      apikey: params.apiKey,
+      Authorization: `Bearer ${params.apiKey}`,
+      'Content-Type': 'application/json',
+    }),
+  },
+
+  /**
+   * The Storage API's update-bucket endpoint is a full-replace PUT
+   * (`{id, name, public, file_size_limit?, allowed_mime_types?}`), not a
+   * partial patch. Fetching the bucket's current configuration first lets
+   * unset params fall back to their existing value instead of silently
+   * resetting to a default (e.g. flipping a public bucket private just
+   * because `isPublic` wasn't provided).
+   */
+  directExecution: async (
+    params: SupabaseStorageUpdateBucketParams
+  ): Promise<SupabaseStorageUpdateBucketResponse> => {
+    const baseUrl = supabaseBaseUrl(params.projectId)
+    const bucket = encodeStorageSegment(params.bucket)
+    const headers = {
+      apikey: params.apiKey,
+      Authorization: `Bearer ${params.apiKey}`,
+      'Content-Type': 'application/json',
+    }
+
+    try {
+      const currentResponse = await fetch(`${baseUrl}/storage/v1/bucket/${bucket}`, {
+        method: 'GET',
+        headers,
+      })
+
+      if (!currentResponse.ok) {
+        const errorText = await currentResponse.text()
+        throw new Error(`Failed to read current bucket configuration: ${errorText}`)
+      }
+
+      const current = await currentResponse.json()
+
+      // Block subBlocks for a shared field can forward an empty string
+      // (e.g. an untouched short-input) rather than omitting the key
+      // entirely — treat that the same as "not provided" so it falls
+      // back to the bucket's current value instead of coercing to 0/false.
+      const hasValue = (value: unknown): boolean =>
+        value !== undefined && value !== null && value !== ''
+
+      const payload: any = {
+        id: params.bucket,
+        name: params.bucket,
+        public: hasValue(params.isPublic) ? params.isPublic : Boolean(current.public),
+        file_size_limit: hasValue(params.fileSizeLimit)
+          ? Number(params.fileSizeLimit)
+          : (current.file_size_limit ?? null),
+        allowed_mime_types: hasValue(params.allowedMimeTypes)
+          ? params.allowedMimeTypes
+          : (current.allowed_mime_types ?? null),
+      }
+
+      const updateResponse = await fetch(`${baseUrl}/storage/v1/bucket/${bucket}`, {
+        method: 'PUT',
+        headers,
+        body: JSON.stringify(payload),
+      })
+
+      if (!updateResponse.ok) {
+        const errorText = await updateResponse.text()
+        throw new Error(`Failed to update bucket: ${errorText}`)
+      }
+
+      const data = await updateResponse.json()
+
+      return {
+        success: true,
+        output: {
+          message: 'Successfully updated storage bucket',
+          results: data,
+        },
+        error: undefined,
+      }
+    } catch (error) {
+      return {
+        success: false,
+        output: {
+          message: 'Failed to update storage bucket',
+          results: {},
+        },
+        error: getErrorMessage(error, 'Unknown error occurred'),
+      }
+    }
+  },
+
+  outputs: {
+    message: { type: 'string', description: 'Operation status message' },
+    results: {
+      type: 'object',
+      description: 'Update operation result',
+      properties: STORAGE_MESSAGE_OUTPUT_PROPERTIES,
+    },
+  },
+}