feat(file): add Set File Sharing operation to the File block

Adds a new file_set_sharing operation to the File block (file_v5) that
idempotently enables/disables a file's public share link and sets its
access mode (public, password, email, SSO). The set_sharing route case
reuses upsertFileShare, requires write/admin, gates enabling through the
EE public-sharing policy, and records a share audit. Returns an empty url
when set to private so a disabled link isn't handed back as a dead link.

Author: TheodoreSpeaks

apps/sim/app/api/tools/file/manage/route.ts

@@ -1,5 +1,6 @@
 import { Buffer, isUtf8 } from 'buffer'
 import type { Readable } from 'stream'
+import { AuditAction, AuditResourceType, recordAudit } from '@sim/audit'
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { generateShortId } from '@sim/utils/id'
@@ -14,6 +15,7 @@ import { generateRequestId } from '@/lib/core/utils/request'
 import { ensureAbsoluteUrl } from '@/lib/core/utils/urls'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { isSupportedFileType, parseBuffer } from '@/lib/file-parsers'
+import { ShareValidationError, upsertFileShare } from '@/lib/public-shares/share-manager'
 import { ensureWorkspaceFileFolderPath } from '@/lib/uploads/contexts/workspace/workspace-file-folder-manager'
 import {
   fetchWorkspaceFileBuffer,
@@ -27,9 +29,14 @@ import { downloadFileFromStorage } from '@/lib/uploads/utils/file-utils.server'
 import { performMoveWorkspaceFileItems } from '@/lib/workspace-files/orchestration'
 import {
   assertActiveWorkspaceAccess,
+  getUserEntityPermissions,
   isWorkspaceAccessDeniedError,
 } from '@/lib/workspaces/permissions/utils'
 import { assertToolFileAccess } from '@/app/api/files/authorization'
+import {
+  PublicFileSharingNotAllowedError,
+  validatePublicFileSharing,
+} from '@/ee/access-control/utils/permission-check'
 import type { UserFile } from '@/executor/types'
 
 export const dynamic = 'force-dynamic'
@@ -565,6 +572,68 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
         })
       }
 
+      case 'set_sharing': {
+        const { fileId, isActive, authType, password, allowedEmails } = body
+
+        const file = await getWorkspaceFile(workspaceId, fileId)
+        if (!file) {
+          return NextResponse.json(
+            { success: false, error: `File not found: "${fileId}"` },
+            { status: 404 }
+          )
+        }
+
+        // Publishing a file is more sensitive than the other mutating ops, so it
+        // requires write/admin (not just workspace access) to match the share route.
+        const permission = await getUserEntityPermissions(userId, 'workspace', workspaceId)
+        if (permission !== 'admin' && permission !== 'write') {
+          return NextResponse.json(
+            { success: false, error: 'Insufficient permissions' },
+            { status: 403 }
+          )
+        }
+
+        // Enabling a share is gated by the org's access-control policy; disabling
+        // is always allowed so users can un-share after the policy is turned on.
+        if (isActive) {
+          try {
+            await validatePublicFileSharing(userId, workspaceId, authType ?? 'public')
+          } catch (error) {
+            if (error instanceof PublicFileSharingNotAllowedError) {
+              return NextResponse.json({ success: false, error: error.message }, { status: 403 })
+            }
+            throw error
+          }
+        }
+
+        const share = await upsertFileShare({
+          workspaceId,
+          fileId,
+          userId,
+          isActive,
+          authType,
+          password,
+          allowedEmails,
+        })
+
+        recordAudit({
+          workspaceId,
+          actorId: userId,
+          action: isActive ? AuditAction.FILE_SHARED : AuditAction.FILE_SHARE_DISABLED,
+          resourceType: AuditResourceType.FILE,
+          resourceId: fileId,
+          resourceName: file.name,
+          description: `${isActive ? 'Enabled' : 'Disabled'} public share for "${file.name}"`,
+          request,
+        })
+
+        logger.info('File sharing updated', { fileId, isActive, authType: share.authType })
+
+        // A disabled link doesn't resolve, so don't hand back a dead URL.
+        const responseShare = share.isActive ? share : { ...share, url: '' }
+        return NextResponse.json({ success: true, data: { share: responseShare } })
+      }
+
       case 'append': {
         const { fileName, content } = body
 
@@ -911,6 +980,9 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
         { status: 403 }
       )
     }
+    if (error instanceof ShareValidationError) {
+      return NextResponse.json({ success: false, error: error.message }, { status: 400 })
+    }
     const message = getErrorMessage(error, 'Unknown error')
     logger.error('File operation failed', { operation: body.operation, error: message })
     return NextResponse.json({ success: false, error: message }, { status: 500 })

apps/sim/blocks/blocks.test.ts

@@ -174,6 +174,7 @@ describe.concurrent('Blocks Module', () => {
         'file_append',
         'file_compress',
         'file_decompress',
+        'file_set_sharing',
       ])
       expect(block?.tools.config?.tool({ operation: 'file_compress' })).toBe('file_compress')
       expect(block?.tools.config?.tool({ operation: 'file_decompress' })).toBe('file_decompress')

apps/sim/blocks/blocks/file.test.ts

@@ -117,4 +117,92 @@ describe('FileV5Block', () => {
       'File is required for get content'
     )
   })
+
+  it('maps set sharing to public access for a canonical file ID', () => {
+    expect(
+      buildParams({
+        operation: 'file_set_sharing',
+        shareInput: 'file-1',
+        shareVisibility: 'public',
+        _context: { workspaceId: 'workspace-1' },
+      })
+    ).toEqual({
+      fileId: 'file-1',
+      isActive: true,
+      authType: 'public',
+      password: undefined,
+      allowedEmails: undefined,
+      workspaceId: 'workspace-1',
+    })
+  })
+
+  it('maps private visibility to a disabled share with no authType', () => {
+    expect(
+      buildParams({
+        operation: 'file_set_sharing',
+        shareInput: 'file-1',
+        shareVisibility: 'private',
+        _context: { workspaceId: 'workspace-1' },
+      })
+    ).toMatchObject({
+      fileId: 'file-1',
+      isActive: false,
+      authType: undefined,
+    })
+  })
+
+  it('passes the password through for password visibility', () => {
+    expect(
+      buildParams({
+        operation: 'file_set_sharing',
+        shareInput: 'file-1',
+        shareVisibility: 'password',
+        sharePassword: 'hunter2',
+        _context: { workspaceId: 'workspace-1' },
+      })
+    ).toMatchObject({
+      fileId: 'file-1',
+      isActive: true,
+      authType: 'password',
+      password: 'hunter2',
+    })
+  })
+
+  it('splits allowed emails for email visibility', () => {
+    expect(
+      buildParams({
+        operation: 'file_set_sharing',
+        shareInput: 'file-1',
+        shareVisibility: 'email',
+        shareAllowedEmails: 'a@example.com, b@example.com\n@acme.com',
+        _context: { workspaceId: 'workspace-1' },
+      })
+    ).toMatchObject({
+      fileId: 'file-1',
+      isActive: true,
+      authType: 'email',
+      allowedEmails: ['a@example.com', 'b@example.com', '@acme.com'],
+    })
+  })
+
+  it('resolves the file ID from a selected workspace file object for set sharing', () => {
+    expect(
+      buildParams({
+        operation: 'file_set_sharing',
+        shareInput: [{ id: 'file-9', name: 'report.pdf' }],
+        shareVisibility: 'public',
+        _context: { workspaceId: 'workspace-1' },
+      })
+    ).toMatchObject({
+      fileId: 'file-9',
+      isActive: true,
+      authType: 'public',
+    })
+  })
+
+  it('throws when no file is provided for set sharing', () => {
+    expect(() => buildParams({ operation: 'file_set_sharing' })).toThrow(
+      'File is required for set sharing'
+    )
+  })
 })