fix(chat): de-dup archive entries by VFS canonical key, not raw path

Greptile: dedup keyed on the raw sanitized path, but archive paths are exposed
through VFS per-segment encoding that NFC-normalizes, so visually-identical
NFC/NFD entries (e.g. café.txt) kept both while emitting one shared vfsPath —
shadowing the second on read. Move dedup to listChatUploadArchiveEntries /
buildArchiveManifest, keyed on the same encodeEntryPath the resolver matches on;
listArchiveEntries now returns raw paths (dedup is a VFS-presentation concern).

Author: waleedlatif1

apps/sim/lib/copilot/tools/handlers/upload-file-reader.test.ts

@@ -245,6 +245,29 @@ describe('readChatUploadPath / listChatUploadArchiveEntries (archive)', () => {
     ])
   })
 
+  it('de-duplicates entries that collapse to one VFS key (NFC/NFD, ./ prefix)', async () => {
+    // "café.txt" stored twice (NFC precomposed + NFD decomposed) plus a
+    // ./-prefixed duplicate of a/b.txt — all collapse to the same VFS path, so
+    // only one of each must be listed (otherwise the second is unreachable).
+    const nfc = `caf\u00e9.txt` // precomposed e-acute
+    const nfd = `cafe\u0301.txt` // e + combining acute
+    expect(nfc).not.toBe(nfd)
+    const buffer = await buildZip({
+      [nfc]: 'nfc',
+      [nfd]: 'nfd',
+      'a/b.txt': 'first',
+      './a/b.txt': 'dup',
+    })
+    mockOrderByThenLimit([makeRow({ displayName: 'bundle.zip', contentType: 'application/zip' })])
+    mockFetchWorkspaceFileBuffer.mockResolvedValueOnce(buffer)
+
+    const entries = await listChatUploadArchiveEntries('bundle.zip', CHAT_ID)
+    const vfsPaths = entries?.map((e) => e.vfsPath) ?? []
+
+    expect(vfsPaths.filter((p) => p === 'uploads/bundle.zip/caf%C3%A9.txt')).toHaveLength(1)
+    expect(vfsPaths.filter((p) => p === 'uploads/bundle.zip/a/b.txt')).toHaveLength(1)
+  })
+
   it('reads a nested entry by its exact path', async () => {
     const buffer = await buildZip({ 'data/sheet.csv': 'a,b\n1,2' })
     mockOrderByThenLimit([makeRow({ displayName: 'bundle.zip', contentType: 'application/zip' })])

apps/sim/lib/copilot/tools/handlers/upload-file-reader.ts

@@ -242,6 +242,25 @@ function archiveEntryKey(path: string): string | null {
   }
 }
 
+/**
+ * De-duplicate raw entry paths by their canonical VFS key (first wins), so two
+ * entries that differ only in a form the VFS normalizes away (NFC vs NFD, U+202F
+ * vs space, collapsed whitespace) collapse to one listed path. This matches how
+ * {@link findArchiveEntryRawPath} resolves a read — first entry whose key matches
+ * — so every listed path is reachable and none is silently shadowed.
+ */
+function dedupeArchiveEntriesByKey(paths: string[]): string[] {
+  const seen = new Set<string>()
+  const result: string[] = []
+  for (const path of paths) {
+    const key = archiveEntryKey(path) ?? path
+    if (seen.has(key)) continue
+    seen.add(key)
+    result.push(path)
+  }
+  return result
+}
+
 /**
  * Resolve a requested entry path (percent-encoded as the agent received it from
  * glob, or the raw display form from the manifest) to the archive's exact stored
@@ -289,7 +308,7 @@ export async function listChatUploadArchiveEntries(
   const encodedZip = encodeUploadName(record.name)
   try {
     const buffer = await fetchWorkspaceFileBuffer(record)
-    const entries = await listArchiveEntries(buffer)
+    const entries = dedupeArchiveEntriesByKey(await listArchiveEntries(buffer))
     return entries.map((path) => ({
       path,
       vfsPath: `uploads/${encodedZip}/${encodeEntryPath(path)}`,
@@ -348,7 +367,7 @@ async function buildArchiveManifest(
 ): Promise<FileReadResult> {
   const encodedZip = encodeUploadName(record.name)
   try {
-    const entries = await listArchiveEntries(archiveBuffer)
+    const entries = dedupeArchiveEntriesByKey(await listArchiveEntries(archiveBuffer))
     const header = `Archive "${record.name}" — ${entries.length} file${
       entries.length === 1 ? '' : 's'
     }. Read an entry with read("uploads/${encodedZip}/<path>").`

apps/sim/lib/uploads/archive.test.ts

@@ -61,17 +61,6 @@ describe('listArchiveEntries', () => {
     expect(paths).not.toContain('evil2.txt')
   })
 
-  it('de-duplicates entries that sanitize to the same path', async () => {
-    const buffer = await buildZip({
-      'a/b.txt': 'first',
-      './a/b.txt': 'shadowed',
-    })
-
-    const paths = await listArchiveEntries(buffer)
-
-    expect(paths).toEqual(['a/b.txt'])
-  })
-
   it('filters __MACOSX, .DS_Store and Thumbs.db noise', async () => {
     const buffer = await buildZip({
       'doc.txt': 'real',

apps/sim/lib/uploads/archive.ts

@@ -152,9 +152,12 @@ async function loadArchive(buffer: Buffer): Promise<JSZip> {
  * Enumerate the safe, extractable entry paths of an archive WITHOUT inflating
  * them, each a sanitized `/`-joined path (e.g. `data/sheet.csv`). Skips
  * directories, symlinks, zip-slip paths, and filesystem noise (`__MACOSX/`,
- * `.DS_Store`, `Thumbs.db`), and de-duplicates entries that sanitize to the same
- * path (e.g. `./a/b` and `a/b`) since only the first is extractable by path.
- * Throws {@link ArchiveError} `too_many_entries` past {@link MAX_ARCHIVE_ENTRIES}.
+ * `.DS_Store`, `Thumbs.db`). Throws {@link ArchiveError} `too_many_entries` past
+ * {@link MAX_ARCHIVE_ENTRIES}.
+ *
+ * Paths are returned raw (not de-duplicated): two entries can collide only once
+ * projected into the VFS's canonical (NFC-encoded) form, so de-duplication
+ * belongs with the caller that owns that encoding (`listChatUploadArchiveEntries`).
  */
 export async function listArchiveEntries(buffer: Buffer): Promise<string[]> {
   const zip = await loadArchive(buffer)
@@ -169,15 +172,11 @@ export async function listArchiveEntries(buffer: Buffer): Promise<string[]> {
     )
   }
 
-  const seen = new Set<string>()
   const paths: string[] = []
   for (const entry of realEntries) {
     const segments = sanitizeArchiveEntryPath(entry.name)
     if (!segments || isArchiveNoiseEntry(segments)) continue
-    const path = segments.join('/')
-    if (seen.has(path)) continue
-    seen.add(path)
-    paths.push(path)
+    paths.push(segments.join('/'))
   }
   return paths
 }