chore: import upstream snapshot with attribution

apps/sim/lib/copilot/tools/handlers/vfs.test.ts

@@ -0,0 +1,407 @@
+/**
+ * @vitest-environment node
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { TOOL_RESULT_MAX_INLINE_CHARS } from '@/lib/copilot/constants'
+
+const { getOrMaterializeVFS } = vi.hoisted(() => ({
+  getOrMaterializeVFS: vi.fn(),
+}))
+
+const { readChatUpload, listChatUploads, grepChatUpload } = vi.hoisted(() => ({
+  readChatUpload: vi.fn(),
+  listChatUploads: vi.fn(),
+  grepChatUpload: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/vfs', () => ({
+  getOrMaterializeVFS,
+}))
+vi.mock('./upload-file-reader', () => ({
+  readChatUpload,
+  listChatUploads,
+  grepChatUpload,
+}))
+
+import { WorkspaceFileGrepError } from '@/lib/copilot/vfs/operations'
+import { executeVfsGlob, executeVfsGrep, executeVfsRead } from './vfs'
+
+const OVERSIZED_INLINE_CONTENT = 'x'.repeat(TOOL_RESULT_MAX_INLINE_CHARS + 1)
+
+function makeVfs() {
+  return {
+    grep: vi.fn(),
+    grepFile: vi.fn(),
+    glob: vi.fn().mockReturnValue([]),
+    read: vi.fn(),
+    readFileContent: vi.fn(),
+    suggestSimilar: vi.fn().mockReturnValue([]),
+  }
+}
+
+const GREP_CTX = { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+const GREP_CTX_CHAT = { ...GREP_CTX, chatId: 'chat-1' }
+
+describe('vfs handlers oversize policy', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('fails oversized grep results with narrowing guidance', async () => {
+    const vfs = makeVfs()
+    vfs.grep.mockReturnValue([{ path: 'files/a.txt', line: 1, content: OVERSIZED_INLINE_CONTENT }])
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsGrep(
+      { pattern: 'foo', output_mode: 'content' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('more specific pattern')
+    expect(result.error).toContain('context window')
+  })
+
+  it('fails oversized read results from VFS with grep guidance', async () => {
+    const vfs = makeVfs()
+    vfs.readFileContent.mockResolvedValue(null)
+    vfs.read.mockReturnValue({ content: OVERSIZED_INLINE_CONTENT, totalLines: 1 })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'workflows/My Workflow/state.json' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Use grep')
+    expect(result.error).toContain('offset/limit')
+    expect(result.error).toContain('context window')
+  })
+
+  it('fails file-backed oversized read placeholders with original message', async () => {
+    const vfs = makeVfs()
+    vfs.readFileContent.mockResolvedValue({
+      content: '[File too large to display inline: big.txt (6000000 bytes, limit 5242880)]',
+      totalLines: 1,
+    })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/big.txt/content' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('File too large to display inline')
+    expect(result.error).toContain('big.txt')
+  })
+
+  it('passes through image reads with attachment even when oversized', async () => {
+    const vfs = makeVfs()
+    const largeBase64 = 'A'.repeat(TOOL_RESULT_MAX_INLINE_CHARS + 1)
+    vfs.readFileContent.mockResolvedValue({
+      content: 'Image: chess.png (500.0KB, image/png)',
+      totalLines: 1,
+      attachment: {
+        type: 'image',
+        source: { type: 'base64', media_type: 'image/png', data: largeBase64 },
+      },
+    })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/chess.png/content' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(true)
+    expect((result.output as { attachment?: { type: string } })?.attachment?.type).toBe('image')
+  })
+
+  it('passes through compiled file attachments even when oversized', async () => {
+    const vfs = makeVfs()
+    const largeBase64 = 'A'.repeat(TOOL_RESULT_MAX_INLINE_CHARS + 1)
+    vfs.readFileContent.mockResolvedValue({
+      content: 'Compiled file: report.pdf (500000 bytes, application/pdf)',
+      totalLines: 1,
+      attachment: {
+        type: 'file',
+        name: 'report.pdf',
+        source: { type: 'base64', media_type: 'application/pdf', data: largeBase64 },
+      },
+    })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/reports/report.pdf/compiled' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(true)
+    expect((result.output as { attachment?: { type: string } })?.attachment?.type).toBe('file')
+  })
+
+  it('fails oversized image placeholder when image exceeds size limit', async () => {
+    const vfs = makeVfs()
+    vfs.readFileContent.mockResolvedValue({
+      content: '[Image too large: huge.png (10.0MB, limit 5MB)]',
+      totalLines: 1,
+    })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/huge.png/content' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('too large')
+  })
+
+  it('reads canonical file leaf metadata without fetching dynamic content', async () => {
+    const vfs = makeVfs()
+    vfs.read.mockReturnValue({
+      content: '{"id":"wf_123","vfsPath":"files/report.csv"}',
+      totalLines: 1,
+    })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/report.csv' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(true)
+    expect(vfs.readFileContent).not.toHaveBeenCalled()
+    expect(vfs.read).toHaveBeenCalledWith('files/report.csv', undefined, undefined)
+  })
+
+  it('uses dynamic file reads for canonical style paths', async () => {
+    const vfs = makeVfs()
+    vfs.readFileContent.mockResolvedValue({
+      content: '{"format":"docx"}',
+      totalLines: 1,
+    })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/reports/brief.docx/style' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(true)
+    expect(vfs.readFileContent).toHaveBeenCalledWith('files/reports/brief.docx/style')
+    expect(vfs.read).not.toHaveBeenCalled()
+  })
+
+  it('uses dynamic file reads for canonical compiled paths', async () => {
+    const vfs = makeVfs()
+    vfs.readFileContent.mockResolvedValue({
+      content: 'Compiled file: brief.pdf (1000 bytes, application/pdf)',
+      totalLines: 1,
+    })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/reports/brief.pdf/compiled' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(true)
+    expect(vfs.readFileContent).toHaveBeenCalledWith('files/reports/brief.pdf/compiled')
+    expect(vfs.read).not.toHaveBeenCalled()
+  })
+})
+
+describe('vfs grep workspace-file routing', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('routes a single workspace file leaf to grepFile (content search)', async () => {
+    const vfs = makeVfs()
+    vfs.grepFile.mockResolvedValue([{ path: 'files/report.csv', line: 2, content: 'revenue,100' }])
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsGrep(
+      { pattern: 'revenue', path: 'files/report.csv', output_mode: 'content' },
+      GREP_CTX
+    )
+
+    expect(result.success).toBe(true)
+    expect(vfs.grepFile).toHaveBeenCalledWith(
+      'files/report.csv',
+      'revenue',
+      expect.objectContaining({ outputMode: 'content', maxResults: 50 })
+    )
+    expect(vfs.grep).not.toHaveBeenCalled()
+    expect((result.output as { matches: unknown[] }).matches).toHaveLength(1)
+  })
+
+  it('routes a files/<leaf>/content path to grepFile', async () => {
+    const vfs = makeVfs()
+    vfs.grepFile.mockResolvedValue([])
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    await executeVfsGrep({ pattern: 'x', path: 'files/reports/brief.pdf/content' }, GREP_CTX)
+
+    expect(vfs.grepFile).toHaveBeenCalledWith(
+      'files/reports/brief.pdf/content',
+      'x',
+      expect.any(Object)
+    )
+    expect(vfs.grep).not.toHaveBeenCalled()
+  })
+
+  it('uses the VFS map grep for non-file paths', async () => {
+    const vfs = makeVfs()
+    vfs.grep.mockReturnValue([])
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    await executeVfsGrep({ pattern: 'slack', path: 'workflows/' }, GREP_CTX)
+
+    expect(vfs.grep).toHaveBeenCalledWith('slack', 'workflows/', expect.any(Object))
+    expect(vfs.grepFile).not.toHaveBeenCalled()
+  })
+
+  it('uses the VFS map grep when no path is given', async () => {
+    const vfs = makeVfs()
+    vfs.grep.mockReturnValue([])
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    await executeVfsGrep({ pattern: 'slack' }, GREP_CTX)
+
+    expect(vfs.grep).toHaveBeenCalledWith('slack', undefined, expect.any(Object))
+    expect(vfs.grepFile).not.toHaveBeenCalled()
+  })
+
+  it('surfaces a workspace-file grep scope error verbatim', async () => {
+    const vfs = makeVfs()
+    vfs.grepFile.mockRejectedValue(
+      new WorkspaceFileGrepError(
+        'Grep over workspace file content must target a single workspace file (e.g. path: "files/report.csv"). "files/" is not a single workspace file.'
+      )
+    )
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsGrep({ pattern: 'x', path: 'files/' }, GREP_CTX)
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('single workspace file')
+  })
+})
+
+describe('vfs uploads are opt-in (like recently-deleted/)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('does not search uploads for an unscoped grep', async () => {
+    const vfs = makeVfs()
+    vfs.grep.mockReturnValue([])
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    await executeVfsGrep({ pattern: 'secret' }, GREP_CTX_CHAT)
+
+    expect(grepChatUpload).not.toHaveBeenCalled()
+    expect(vfs.grep).toHaveBeenCalledWith('secret', undefined, expect.any(Object))
+  })
+
+  it('does not search uploads for a files/ grep', async () => {
+    const vfs = makeVfs()
+    vfs.grepFile.mockResolvedValue([])
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    await executeVfsGrep({ pattern: 'secret', path: 'files/report.csv' }, GREP_CTX_CHAT)
+
+    expect(grepChatUpload).not.toHaveBeenCalled()
+  })
+
+  it('routes an explicit uploads/<file> path to grepChatUpload', async () => {
+    grepChatUpload.mockResolvedValue([{ path: 'uploads/report.json', line: 1, content: 'hit' }])
+
+    const result = await executeVfsGrep(
+      { pattern: 'hit', path: 'uploads/report.json' },
+      GREP_CTX_CHAT
+    )
+
+    expect(result.success).toBe(true)
+    expect(grepChatUpload).toHaveBeenCalledWith(
+      'report.json',
+      'chat-1',
+      'hit',
+      expect.objectContaining({ maxResults: 50 })
+    )
+    expect(getOrMaterializeVFS).not.toHaveBeenCalled()
+  })
+
+  it('rejects a bare uploads/ folder grep (no cross-folder search)', async () => {
+    const result = await executeVfsGrep({ pattern: 'x', path: 'uploads/' }, GREP_CTX_CHAT)
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('single upload')
+    expect(grepChatUpload).not.toHaveBeenCalled()
+  })
+
+  it('errors when grepping uploads without chat context', async () => {
+    const result = await executeVfsGrep({ pattern: 'x', path: 'uploads/report.json' }, GREP_CTX)
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('No chat context')
+    expect(grepChatUpload).not.toHaveBeenCalled()
+  })
+
+  it('surfaces an upload-not-found grep error verbatim', async () => {
+    grepChatUpload.mockRejectedValue(
+      new WorkspaceFileGrepError(
+        'Upload not found: "ghost.json". Use glob("uploads/*") to list available uploads.'
+      )
+    )
+
+    const result = await executeVfsGrep({ pattern: 'x', path: 'uploads/ghost.json' }, GREP_CTX_CHAT)
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Upload not found')
+  })
+
+  it('lists uploads only when scoped, with percent-encoded paths', async () => {
+    const vfs = makeVfs()
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+    listChatUploads.mockResolvedValue([{ name: 'My Report.json' }, { name: 'data.csv' }])
+
+    const scoped = await executeVfsGlob({ pattern: 'uploads/*' }, GREP_CTX_CHAT)
+    expect((scoped.output as { files: string[] }).files).toEqual(
+      expect.arrayContaining(['uploads/My%20Report.json', 'uploads/data.csv'])
+    )
+
+    listChatUploads.mockClear()
+    const broad = await executeVfsGlob({ pattern: '**' }, GREP_CTX_CHAT)
+    expect(listChatUploads).not.toHaveBeenCalled()
+    expect((broad.output as { files: string[] }).files).not.toContain('uploads/My%20Report.json')
+  })
+
+  it('reads an upload directly, tolerating a spurious /content suffix', async () => {
+    const vfs = makeVfs()
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+    readChatUpload.mockResolvedValue({ content: 'hello upload', totalLines: 1 })
+
+    const bare = await executeVfsRead({ path: 'uploads/report.csv' }, GREP_CTX_CHAT)
+    expect(bare.success).toBe(true)
+    expect(readChatUpload).toHaveBeenLastCalledWith('report.csv', 'chat-1')
+
+    // The model adds /content out of habit (from files/) — it must still resolve.
+    const withContent = await executeVfsRead({ path: 'uploads/report.csv/content' }, GREP_CTX_CHAT)
+    expect(withContent.success).toBe(true)
+    expect(readChatUpload).toHaveBeenLastCalledWith('report.csv', 'chat-1')
+  })
+
+  it('tolerates a trailing /content on an uploads grep path', async () => {
+    grepChatUpload.mockResolvedValue([])
+
+    await executeVfsGrep({ pattern: 'x', path: 'uploads/report.json/content' }, GREP_CTX_CHAT)
+
+    expect(grepChatUpload).toHaveBeenCalledWith('report.json', 'chat-1', 'x', expect.any(Object))
+  })
+})