fix(files): reconnect folder scope to the operation that runs it

Three P1s from cubic, all real, all mine, and all introduced by the rebase.

Folder expansion was gone from read, get content and compress. Taking the
upstream copy of the operations file and re-applying only the folder CASES
dropped expandFolderPathsToFileIds and the folderPaths handling with it, so the
block sent a folder, the contract accepted it, the tool forwarded it, and the
operation ignored it — a folder-only selection failed with "File is required".

file_write never read folderPath: it derived the destination from the file name
alone, so choosing a folder wrote to the workspace root. It now prefixes the
picked folder's decoded segments onto whatever the name itself spells.

The six folder tool ids were registered in FILE_MANAGE_TOOL_IDS, which chooses
the handler branch, but not in FILE_TOOL_IDS, which decides whether the internal
registry has a handler at all. Every workflow execution of them would have
failed before reaching the branch.

None of this was caught because the tests covered the two ends — the block's
params and the pure path helpers — and nothing covered the middle. Worse, the
test file's module mock stubbed one export from workspace-file-folders, so the
five folder operations were undefined and no test could reach a folder case at
all. The mock is complete now, and five tests cover the wiring: a folder-only
read expands, a missing folder refuses rather than reading nothing, write lands
in the chosen folder and still lands at the root without one, and list returns
folders and files together.

Author: mzxchandra

apps/sim/lib/internal/file/operations.test.ts

@@ -11,6 +11,12 @@ const {
   mockDownloadFileFromStorage,
   mockDecompressArchiveBufferToWorkspaceFiles,
   mockEnsureWorkspaceFileFolderPath,
+  mockListWorkspaceFileFolders,
+  mockCreateWorkspaceFileFolder,
+  mockUpdateWorkspaceFileFolder,
+  mockDeleteWorkspaceFileFolder,
+  mockRestoreWorkspaceFileFolder,
+  mockListAllWorkspaceFiles,
   mockFetchWorkspaceFileBuffer,
   mockGetBoundWorkspaceFileSecretProvenance,
   mockLoadActiveWorkspaceContext,
@@ -29,6 +35,12 @@ const {
   mockDownloadFileFromStorage: vi.fn(),
   mockDecompressArchiveBufferToWorkspaceFiles: vi.fn(),
   mockEnsureWorkspaceFileFolderPath: vi.fn(),
+  mockListWorkspaceFileFolders: vi.fn(),
+  mockCreateWorkspaceFileFolder: vi.fn(),
+  mockUpdateWorkspaceFileFolder: vi.fn(),
+  mockDeleteWorkspaceFileFolder: vi.fn(),
+  mockRestoreWorkspaceFileFolder: vi.fn(),
+  mockListAllWorkspaceFiles: vi.fn(),
   mockFetchWorkspaceFileBuffer: vi.fn(),
   mockGetBoundWorkspaceFileSecretProvenance: vi.fn(),
   mockLoadActiveWorkspaceContext: vi.fn(),
@@ -107,6 +119,25 @@ vi.mock('@/lib/workspace-files/application/workspace-file-folders', () => ({
   ensureWorkspaceFileFolderPathOperation: {
     execute: (...args: unknown[]) => mockEnsureWorkspaceFileFolderPath(...args),
   },
+  listWorkspaceFileFoldersOperation: {
+    execute: (...args: unknown[]) => mockListWorkspaceFileFolders(...args),
+  },
+  createWorkspaceFileFolderOperation: {
+    execute: (...args: unknown[]) => mockCreateWorkspaceFileFolder(...args),
+  },
+  updateWorkspaceFileFolderOperation: {
+    execute: (...args: unknown[]) => mockUpdateWorkspaceFileFolder(...args),
+  },
+  deleteWorkspaceFileFolderOperation: {
+    execute: (...args: unknown[]) => mockDeleteWorkspaceFileFolder(...args),
+  },
+  restoreWorkspaceFileFolderOperation: {
+    execute: (...args: unknown[]) => mockRestoreWorkspaceFileFolder(...args),
+  },
+}))
+
+vi.mock('@/lib/workspace-files/application/list-workspace-files', () => ({
+  listAllWorkspaceFiles: { execute: (...args: unknown[]) => mockListAllWorkspaceFiles(...args) },
 }))
 
 vi.mock('@/lib/workspace-files/application/move-workspace-file-items', () => ({
@@ -245,6 +276,144 @@ function actorlessDeploymentPrincipal(workspaceId = 'workspace-1') {
   }
 }
 
+/*
+ * The folder path exists in three places — the block's params, the contract, and
+ * the operation — and only the two ends were tested. A rebase dropped folder
+ * expansion out of the middle, and every unit test stayed green while a
+ * folder-only read failed with "File is required". These cover the middle.
+ */
+describe('file manage folder wiring', () => {
+  const FOLDER_ROW = {
+    id: 'folder-reports',
+    parentId: null,
+    name: 'Reports',
+    path: 'Reports',
+    createdAt: CONTENT_UPDATED_AT,
+    updatedAt: CONTENT_UPDATED_AT,
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    hybridAuthMockFns.mockCheckInternalAuth.mockResolvedValue({
+      success: true,
+      userId: 'user-1',
+      authType: 'internal_jwt',
+    })
+    mockAssertActiveWorkspaceAccess.mockResolvedValue(undefined)
+    mockResolveEffectiveWorkspacePermission.mockResolvedValue('write')
+    mockLoadActiveWorkspaceContext.mockResolvedValue({
+      workspaceId: 'workspace-1',
+      workspaceOrganizationId: null,
+      allowPersonalApiKeys: true,
+      billedAccountUserId: 'user-1',
+    })
+    mockVerifyFileAccess.mockResolvedValue(true)
+    mockGetWorkspaceFile.mockImplementation(async (_ws: string, fileId: string) =>
+      workspaceFile(fileId)
+    )
+    mockLoadActiveWorkspaceFileContext.mockImplementation(async (fileId: string) => ({
+      fileId,
+      workspaceId: 'workspace-1',
+      workspaceOrganizationId: null,
+      allowPersonalApiKeys: true,
+      billedAccountUserId: 'user-1',
+    }))
+    mockListWorkspaceFileFolders.mockResolvedValue({ folders: [FOLDER_ROW] })
+    mockListAllWorkspaceFiles.mockResolvedValue({
+      files: [
+        { ...workspaceFile('file-in-folder'), folderId: 'folder-reports' },
+        { ...workspaceFile('file-at-root'), folderId: null },
+      ],
+    })
+    mockEnsureWorkspaceFileFolderPath.mockImplementation(
+      async ({ input }: { input: { pathSegments: string[] } }) => ({
+        folderId: input.pathSegments.length === 0 ? null : 'folder-reports',
+        createdFolderIds: [],
+      })
+    )
+    mockUploadWorkspaceFile.mockResolvedValue({
+      id: 'new-file',
+      name: 'new.txt',
+      key: 'workspace/workspace-1/new.txt',
+      url: '/api/files/serve/new-file',
+    })
+  })
+
+  it('expands a folder-only read instead of rejecting it', async () => {
+    const response = await POST(
+      createMockRequest('POST', {
+        operation: 'read',
+        workspaceId: 'workspace-1',
+        folderPaths: ['/Reports'],
+      })
+    )
+
+    // A folder alone is a complete selection, expanded when the workflow runs.
+    expect(response.status).not.toBe(400)
+    expect(mockListWorkspaceFileFolders).toHaveBeenCalled()
+    expect(mockListAllWorkspaceFiles).toHaveBeenCalled()
+  })
+
+  it('refuses a folder that does not exist rather than reading nothing', async () => {
+    const response = await POST(
+      createMockRequest('POST', {
+        operation: 'read',
+        workspaceId: 'workspace-1',
+        folderPaths: ['/Nope'],
+      })
+    )
+    const body = await response.json()
+
+    expect(body.success).toBe(false)
+    expect(String(body.error)).toContain('Folder not found')
+  })
+
+  it('writes into the folder it was given, not the workspace root', async () => {
+    await POST(
+      createMockRequest('POST', {
+        operation: 'write',
+        workspaceId: 'workspace-1',
+        fileName: 'notes.md',
+        folderPath: '/Reports',
+        content: 'hello',
+      })
+    )
+
+    expect(mockEnsureWorkspaceFileFolderPath).toHaveBeenCalledWith(
+      expect.objectContaining({ input: expect.objectContaining({ pathSegments: ['Reports'] }) })
+    )
+  })
+
+  it('still writes to the root when no folder is given', async () => {
+    await POST(
+      createMockRequest('POST', {
+        operation: 'write',
+        workspaceId: 'workspace-1',
+        fileName: 'notes.md',
+        content: 'hello',
+      })
+    )
+
+    expect(mockEnsureWorkspaceFileFolderPath).toHaveBeenCalledWith(
+      expect.objectContaining({ input: expect.objectContaining({ pathSegments: [] }) })
+    )
+  })
+
+  it('lists what a folder holds, folders and files together', async () => {
+    const response = await POST(
+      createMockRequest('POST', { operation: 'list', workspaceId: 'workspace-1' })
+    )
+    const body = await response.json()
+
+    expect(body.success).toBe(true)
+    expect(body.data.entries.map((entry: { name: string }) => entry.name)).toEqual([
+      'Reports',
+      'file-at-root.txt',
+    ])
+    expect(body.data.truncated).toBe(false)
+  })
+})
+
 describe('file manage operations', () => {
   beforeEach(() => {
     vi.clearAllMocks()

apps/sim/lib/internal/file/operations.ts

@@ -27,7 +27,7 @@ import {
   requestsPrivateToolMetadata,
 } from '@/lib/execution/private-tool-metadata'
 import { isSupportedFileType, parseBuffer } from '@/lib/file-parsers'
-import { buildFolderPath, ROOT_FOLDER_PATH } from '@/lib/folders/paths'
+import { buildFolderPath, parseFolderPath, ROOT_FOLDER_PATH } from '@/lib/folders/paths'
 import { ShareValidationError } from '@/lib/public-shares/share-manager'
 import {
   ArchiveError,
@@ -567,6 +567,53 @@ export function fileContentJsonResponse(
   )
 }
 
+/**
+ * Expands folder paths to the ids of every file beneath them.
+ *
+ * Resolution happens here, at run time, rather than when the block is
+ * configured: picking a folder means "whatever is in it when this runs", so a
+ * file added tomorrow is read tomorrow. Expanding in the picker would freeze a
+ * snapshot instead.
+ *
+ * Path resolution itself lives in {@link resolveFolderIdsForPaths}; this is the
+ * IO around it.
+ */
+async function expandFolderPathsToFileIds(args: {
+  principal: Principal
+  workspaceId: string
+  folderPaths: string[] | undefined
+  includeSubfolders: boolean | undefined
+}): Promise<string[]> {
+  if (!args.folderPaths?.length) return []
+
+  const [{ folders }, { files }] = await Promise.all([
+    listWorkspaceFileFoldersOperation.execute({
+      principal: args.principal,
+      input: { workspaceId: args.workspaceId },
+    }),
+    listAllWorkspaceFiles.execute({
+      principal: args.principal,
+      input: { workspaceId: args.workspaceId, scope: 'active' },
+    }),
+  ])
+
+  const projected = folders.map((folder) => ({
+    ...toWorkspaceFileFolderPathView(folder),
+    id: folder.id,
+    parentId: folder.parentId,
+  }))
+  const selection = resolveFolderIdsForPaths(projected, args.folderPaths, {
+    includeSubfolders: args.includeSubfolders,
+  })
+  if (selection.missingPath !== undefined) {
+    throw new OrchestrationError('not_found', `Folder not found: ${selection.missingPath}`)
+  }
+
+  return files
+    .filter((file) => file.folderId && selection.folderIds.has(file.folderId))
+    .map((file) => file.id)
+}
+
 export async function executeFileManageOperation(
   body: FileManageOperationInput,
   context: FileManageOperationContext
@@ -638,14 +685,24 @@ export async function executeFileManageOperation(
       }
 
       case 'read': {
-        const { fileId, fileInput } = body
+        const { fileId, fileInput, folderPaths, includeSubfolders } = body
         const selectedFileIds = Array.isArray(fileId)
           ? fileId.map((id) => id.trim()).filter(Boolean)
           : fileId
             ? normalizeFileIdList(fileId)
             : extractFileIdsFromInput(fileInput)
         const selectedInputFiles = fileId ? [] : extractUserFilesFromInput(fileInput)
 
+        signal?.throwIfAborted()
+        for (const id of await expandFolderPathsToFileIds({
+          principal,
+          workspaceId,
+          folderPaths,
+          includeSubfolders,
+        })) {
+          if (!selectedFileIds.includes(id)) selectedFileIds.push(id)
+        }
+
         if (selectedFileIds.length === 0 && selectedInputFiles.length === 0) {
           return Response.json({ success: false, error: 'File is required' }, { status: 400 })
         }
@@ -729,14 +786,24 @@ export async function executeFileManageOperation(
       }
 
       case 'content': {
-        const { fileId, fileInput } = body
+        const { fileId, fileInput, folderPaths, includeSubfolders } = body
         const selectedFileIds = Array.isArray(fileId)
           ? fileId.map((id) => id.trim()).filter(Boolean)
           : fileId
             ? normalizeFileIdList(fileId)
             : extractFileIdsFromInput(fileInput)
         const selectedInputFiles = fileId ? [] : extractUserFilesFromInput(fileInput)
 
+        signal?.throwIfAborted()
+        for (const id of await expandFolderPathsToFileIds({
+          principal,
+          workspaceId,
+          folderPaths,
+          includeSubfolders,
+        })) {
+          if (!selectedFileIds.includes(id)) selectedFileIds.push(id)
+        }
+
         if (selectedFileIds.length === 0 && selectedInputFiles.length === 0) {
           return contentResponse({ success: false, error: 'File is required' }, { status: 400 })
         }
@@ -828,7 +895,7 @@ export async function executeFileManageOperation(
       }
 
       case 'write': {
-        const { fileName, content, fileInput, contentType, overwrite } = body
+        const { fileName, content, fileInput, contentType, overwrite, folderPath } = body
         signal?.throwIfAborted()
         const provenanceResolution = resolveFileWriteSecretProvenance({
           headers,
@@ -920,7 +987,16 @@ export async function executeFileManageOperation(
           ? mergeWorkspaceFileSecretProvenance(...writeProvenanceSources)
           : undefined
 
-        const { folderSegments, leafName } = splitWorkspaceFilePath(sourceName ?? '')
+        const { folderSegments: nameSegments, leafName } = splitWorkspaceFilePath(sourceName ?? '')
+        /*
+         * The destination is the picked folder, then whatever folders the name
+         * itself spells. `folderPath` is canonical and percent-encoded, so it is
+         * decoded to names here — the same names `splitWorkspaceFilePath` yields
+         * — because the folder operation takes decoded segments.
+         */
+        const folderSegments = folderPath
+          ? [...parseFolderPath(folderPath), ...nameSegments]
+          : nameSegments
         await admitCreateWorkspaceFile(principal, workspaceId)
         const { folderId } = await ensureWorkspaceFileFolderPathOperation.execute({
           principal,
@@ -1206,14 +1282,24 @@ export async function executeFileManageOperation(
       }
 
       case 'compress': {
-        const { fileId, fileInput, archiveName } = body
+        const { fileId, fileInput, archiveName, folderPaths, includeSubfolders } = body
         const selectedFileIds = Array.isArray(fileId)
           ? fileId.map((id) => id.trim()).filter(Boolean)
           : fileId
             ? normalizeFileIdList(fileId)
             : extractFileIdsFromInput(fileInput)
         const selectedInputFiles = fileId ? [] : extractUserFilesFromInput(fileInput)
 
+        signal?.throwIfAborted()
+        for (const id of await expandFolderPathsToFileIds({
+          principal,
+          workspaceId,
+          folderPaths,
+          includeSubfolders,
+        })) {
+          if (!selectedFileIds.includes(id)) selectedFileIds.push(id)
+        }
+
         if (selectedFileIds.length === 0 && selectedInputFiles.length === 0) {
           return Response.json({ success: false, error: 'File is required' }, { status: 400 })
         }

apps/sim/lib/internal/tool-operations/registry.server.ts

@@ -837,6 +837,12 @@ const FILE_TOOL_IDS = [
   'file_parser',
   'file_parser_v2',
   'file_parser_v3',
+  'file_list',
+  'file_create_folder',
+  'file_update_folder',
+  'file_delete_folder',
+  'file_restore_folder',
+  'file_move',
 ] as const
 
 const UPTIMEROBOT_TOOL_IDS = ['uptimerobot_create_psp', 'uptimerobot_update_psp'] as const