fix(files): preserve scoped listing semantics

Author: Vikhyath Mondreti

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

@@ -535,7 +535,7 @@ describe('file manage folder wiring', () => {
         })
       )
 
-      expect(mockResolveWorkspaceFileReference).not.toHaveBeenCalledWith('workspace-1', 'b-self')
+      expect(mockResolveWorkspaceFileReference).toHaveBeenCalledWith('workspace-1', 'a-self')
     })
 
     it('passes the replacement through as a string edit', async () => {
@@ -960,6 +960,58 @@ describe('file manage folder wiring', () => {
       })
     )
   })
+
+  it('fills a recursive page from shallower files before deeper files', async () => {
+    mockListWorkspaceFileFolders.mockResolvedValue({ folders: [FOLDER_ROW] })
+    mockQueryWorkspaceFilePage.mockImplementation(
+      async ({ input }: { input: { folderScope: { includeRootItems: boolean } } }) =>
+        input.folderScope.includeRootItems
+          ? {
+              files: [{ ...workspaceFile('root-z'), name: 'z.txt', folderId: null }],
+              nextKeys: null,
+            }
+          : {
+              files: [{ ...workspaceFile('nested-a'), name: 'a.txt', folderId: 'folder-reports' }],
+              nextKeys: null,
+            }
+    )
+
+    const response = await POST(
+      createMockRequest('POST', {
+        operation: 'list',
+        workspaceId: 'workspace-1',
+        recursive: true,
+        limit: 2,
+      })
+    )
+    const body = await response.json()
+
+    expect(body.data.entries.map((entry: { name: string }) => entry.name)).toEqual([
+      'Reports',
+      'z.txt',
+    ])
+    expect(body.data.truncated).toBe(true)
+    expect(mockQueryWorkspaceFilePage).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        input: expect.objectContaining({
+          folderScope: { folderIds: new Set<string>(), includeRootItems: true },
+        }),
+      })
+    )
+    expect(mockQueryWorkspaceFilePage).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        input: expect.objectContaining({
+          folderScope: {
+            folderIds: new Set<string>(['folder-reports']),
+            includeRootItems: false,
+          },
+          limit: 1,
+        }),
+      })
+    )
+  })
 })
 
 describe('file manage operations', () => {

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

@@ -28,6 +28,7 @@ import {
 } from '@/lib/execution/private-tool-metadata'
 import { isSupportedFileType, parseBuffer } from '@/lib/file-parsers'
 import { buildFolderPath, parseFolderPath, ROOT_FOLDER_PATH } from '@/lib/folders/paths'
+import type { FolderIdScope } from '@/lib/folders/scope'
 import { collectFolderDepths } from '@/lib/folders/subtree'
 import { ShareValidationError } from '@/lib/public-shares/share-manager'
 import {
@@ -125,6 +126,29 @@ export interface FileManageOperationContext {
   signal?: AbortSignal
 }
 
+function directoryFileScopeForDepthRange(
+  rootId: string | null,
+  folderDepths: ReadonlyMap<string, number>,
+  minDepth: number,
+  maxDepth: number
+): FolderIdScope {
+  const folderIds = new Set<string>()
+
+  if (minDepth <= 0 && maxDepth >= 0 && rootId !== null) folderIds.add(rootId)
+  for (const [folderId, depth] of folderDepths) {
+    if (depth >= minDepth && depth <= maxDepth) folderIds.add(folderId)
+  }
+
+  return {
+    folderIds,
+    includeRootItems: rootId === null && minDepth <= 0 && maxDepth >= 0,
+  }
+}
+
+function hasDirectoryFileScope(scope: FolderIdScope): boolean {
+  return scope.includeRootItems || scope.folderIds.size > 0
+}
+
 async function assertOperationFileAccess(
   file: Pick<UserFile, 'key' | 'context'>,
   context: FileManageOperationContext
@@ -1986,27 +2010,105 @@ export async function executeFileManageOperation(
         }
 
         const maxDepth = body.recursive ? (body.depth ?? Number.POSITIVE_INFINITY) : 1
-        const fileParentDepths = collectFolderDepths(projected, rootId, {
-          maxDepth: Math.max(0, maxDepth - 1),
-        })
-        const folderIds = new Set(fileParentDepths.keys())
-        if (rootId) folderIds.add(rootId)
         const limit = body.limit ?? DEFAULT_FILE_LIST_LIMIT
-        const filePage = await queryWorkspaceFilePage.execute({
-          principal,
-          input: {
-            workspaceId,
-            folderScope: { folderIds, includeRootItems: rootId === null },
-            search: body.search,
-            sortBy: 'name',
-            sortOrder: 'asc',
-            limit,
-          },
+        const folderDepths = collectFolderDepths(projected, rootId, { maxDepth })
+        let maxParentDepth = 0
+        for (const depth of folderDepths.values()) {
+          if (depth < maxDepth) maxParentDepth = Math.max(maxParentDepth, depth)
+        }
+
+        const folderListing = selectDirectoryEntries(projected, [], {
+          rootId,
+          rootPath,
+          maxDepth,
+          search: body.search,
+          limit: projected.length,
         })
+        const matchingFolderCountByDepth = new Map<number, number>()
+        for (const entry of folderListing.entries) {
+          matchingFolderCountByDepth.set(
+            entry.depth,
+            (matchingFolderCountByDepth.get(entry.depth) ?? 0) + 1
+          )
+        }
+
+        const files: WorkspaceFileRecord[] = []
+        let processedMatchingFolders = 0
+        let fileListingTruncated = false
+
+        const queryFileScope = (folderScope: FolderIdScope, pageLimit: number) =>
+          queryWorkspaceFilePage.execute({
+            principal,
+            input: {
+              workspaceId,
+              folderScope,
+              search: body.search,
+              sortBy: 'name',
+              sortOrder: 'asc',
+              limit: pageLimit,
+            },
+          })
+
+        for (let fileDepth = 1; fileDepth <= maxParentDepth + 1; fileDepth++) {
+          processedMatchingFolders += matchingFolderCountByDepth.get(fileDepth) ?? 0
+          const parentDepth = fileDepth - 1
+          const knownEntryCount = processedMatchingFolders + files.length
+
+          if (knownEntryCount >= limit) {
+            fileListingTruncated =
+              knownEntryCount > limit || folderListing.entries.length > processedMatchingFolders
+            if (!fileListingTruncated) {
+              const remainingScope = directoryFileScopeForDepthRange(
+                rootId,
+                folderDepths,
+                parentDepth,
+                maxParentDepth
+              )
+              if (hasDirectoryFileScope(remainingScope)) {
+                const remainingPage = await queryFileScope(remainingScope, 1)
+                fileListingTruncated = remainingPage.files.length > 0
+              }
+            }
+            break
+          }
+
+          const depthScope = directoryFileScopeForDepthRange(
+            rootId,
+            folderDepths,
+            parentDepth,
+            parentDepth
+          )
+          if (!hasDirectoryFileScope(depthScope)) continue
+
+          const filePage = await queryFileScope(depthScope, limit)
+          files.push(...filePage.files)
+
+          const populatedEntryCount = processedMatchingFolders + files.length
+          if (filePage.nextKeys !== null || populatedEntryCount > limit) {
+            fileListingTruncated = true
+            break
+          }
+          if (populatedEntryCount === limit) {
+            fileListingTruncated = folderListing.entries.length > processedMatchingFolders
+            if (!fileListingTruncated && parentDepth < maxParentDepth) {
+              const remainingScope = directoryFileScopeForDepthRange(
+                rootId,
+                folderDepths,
+                parentDepth + 1,
+                maxParentDepth
+              )
+              if (hasDirectoryFileScope(remainingScope)) {
+                const remainingPage = await queryFileScope(remainingScope, 1)
+                fileListingTruncated = remainingPage.files.length > 0
+              }
+            }
+            break
+          }
+        }
 
         const listing = selectDirectoryEntries(
           projected,
-          filePage.files.map((file) => ({
+          files.map((file) => ({
             id: file.id,
             name: file.name,
             folderId: file.folderId ?? null,
@@ -2028,7 +2130,7 @@ export async function executeFileManageOperation(
           data: {
             path: rootPath,
             entries: listing.entries,
-            truncated: listing.truncated || filePage.nextKeys !== null,
+            truncated: listing.truncated || fileListingTruncated,
           },
         })
       }

apps/sim/lib/workspace-files/application/resolve-workspace-file-reference.test.ts

@@ -106,6 +106,24 @@ describe('workspace file reference application service', () => {
     expect(mocks.resolvePermission).toHaveBeenCalledTimes(1)
   })
 
+  it('reads an exact name directly inside a canonical folder id', async () => {
+    await expect(
+      readWorkspaceFileReference({
+        principal,
+        workspaceId: 'workspace-1',
+        reference: 'source.txt',
+        folderId: 'folder-1',
+        maxBytes: 512,
+      })
+    ).resolves.toEqual({ file, content: Buffer.from('source') })
+
+    expect(mocks.getByName).toHaveBeenCalledWith('workspace-1', 'source.txt', {
+      folderId: 'folder-1',
+    })
+    expect(mocks.resolveStoredReference).not.toHaveBeenCalled()
+    expect(mocks.fetchBuffer).toHaveBeenCalledWith(file, { maxBytes: 512 })
+  })
+
   it('fails before canonical loading for an unregistered operation object', async () => {
     const duplicateOperation = defineWorkspaceOperation({
       id: fileOperations.rename.id,

apps/sim/lib/workspace-files/application/resolve-workspace-file-reference.ts

@@ -129,10 +129,16 @@ export async function readWorkspaceFileReference({
   principal,
   workspaceId,
   reference,
+  folderId,
   maxBytes,
 }: ReadWorkspaceFileReferenceInput): Promise<{ file: WorkspaceFileRecord; content: Buffer }> {
   return readWorkspaceFileReferenceUseCase.execute({
     principal,
-    input: { workspaceId, reference, maxBytes },
+    input: {
+      workspaceId,
+      reference,
+      maxBytes,
+      ...(folderId === undefined ? {} : { folderId }),
+    },
   })
 }

apps/sim/lib/workspace-files/edit-content.test.ts

@@ -104,6 +104,25 @@ describe('applyWorkspaceFileContentEdit', () => {
     ).toBe('heading\r\n  anchor  \r\none\r\ntwo\r\ntail\r\n')
   })
 
+  it('does not add a blank line when anchored content ends with a newline', () => {
+    expect(
+      applyWorkspaceFileContentEdit('before\nold\nafter\n', {
+        mode: 'replace_between',
+        beforeAnchor: 'before',
+        afterAnchor: 'after',
+        content: 'new\n',
+      })
+    ).toBe('before\nnew\nafter\n')
+
+    expect(
+      applyWorkspaceFileContentEdit('anchor\ntail\n', {
+        mode: 'insert_after',
+        anchor: 'anchor',
+        content: 'new\n',
+      })
+    ).toBe('anchor\nnew\ntail\n')
+  })
+
   it('deletes the start anchor and interior while preserving the end anchor', () => {
     expect(
       applyWorkspaceFileContentEdit('before\nstart\nremove\nend\nafter', {

apps/sim/lib/workspace-files/edit-content.ts

@@ -171,7 +171,9 @@ function anchorLineIndex(lines: string[], anchor: string, occurrence: number): n
 }
 
 function contentLines(content: string): string[] {
-  return content.length === 0 ? [] : splitLines(content)
+  if (content.length === 0) return []
+  const lines = splitLines(content)
+  return lines.at(-1) === '' ? lines.slice(0, -1) : lines
 }
 
 /**