fix(zip-uploads): detect prior nested-only extractions in the re-extract guard

The already-extracted check only looked for files directly inside the
archive root folder, so a zip whose entries are all nested (src/index.ts)
left only subfolders there and a second extract slipped past the guard,
duplicating the tree with ' (1)' suffixes. Extraction roots its whole tree
at that folder, so a prior run always leaves a direct file OR a direct
subfolder — check both.

Author: Sg312

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

@@ -411,6 +411,25 @@ describe('executeMaterializeFile - extract operation', () => {
     expect(mockDecompress).not.toHaveBeenCalled()
   })
 
+  it('detects a prior nested-only extraction via subfolders, not just direct files', async () => {
+    // A zip containing only nested entries (src/index.ts) leaves NO direct files
+    // under the archive root — only subfolders. The guard must still refuse.
+    mockFindUpload.mockResolvedValue(zipRow())
+    mockFindFolder.mockResolvedValue('folder-existing')
+    dbChainMockFns.limit.mockResolvedValueOnce([]) // no direct files
+    dbChainMockFns.limit.mockResolvedValueOnce([{ id: 'subfolder-1' }]) // but a subfolder tree
+
+    const result = await executeMaterializeFile(
+      { fileNames: ['bundle.zip'], operation: 'extract' },
+      context
+    )
+
+    expect(result.success).toBe(false)
+    const output = result.output as { failed: Array<{ fileName: string; error: string }> }
+    expect(output.failed[0].error).toContain('already extracted')
+    expect(mockDecompress).not.toHaveBeenCalled()
+  })
+
   it('dedupes repeated fileNames so one call cannot double-extract', async () => {
     mockFindUpload.mockResolvedValue(zipRow())
     mockFetchBuffer.mockResolvedValue(Buffer.from('zip-bytes'))

apps/sim/lib/copilot/tools/handlers/materialize-file.ts

@@ -1,6 +1,6 @@
 import { AuditAction, AuditResourceType, recordAudit } from '@sim/audit'
 import { db } from '@sim/db'
-import { workflow, workspaceFiles } from '@sim/db/schema'
+import { workflow, workspaceFileFolder, workspaceFiles } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { getErrorMessage, toError } from '@sim/utils/errors'
 import { generateId } from '@sim/utils/id'
@@ -312,7 +312,6 @@ function archiveFolderBaseName(displayName: string): string {
   const stripped = displayName
     .replace(/\.zip$/i, '')
     .normalize('NFC')
-    // biome-ignore lint/suspicious/noControlCharactersInRegex: intentionally stripping control chars
     .replace(/[\x00-\x1f\x7f]/g, '')
     .replace(/[/\\]/g, '-')
     .trim()
@@ -379,25 +378,40 @@ async function executeExtract(
   const folderPath = `files/${encodeVfsPathSegments([baseName])}`
 
   // Re-running extract must not silently duplicate the tree with " (1)"-suffixed
-  // copies: when the destination folder already holds files, report it as
-  // already extracted instead of extracting beside the previous run.
+  // copies: when the destination folder already holds content, report it as
+  // already extracted instead of extracting beside the previous run. Direct
+  // files AND direct subfolders both count — extraction roots its whole tree
+  // here, so a prior run of a nested-only zip (e.g. src/index.ts) leaves a
+  // subfolder even when no file sits at the top level.
   const existingFolderId = await findWorkspaceFileFolderIdByPath(workspaceId, [baseName])
   if (existingFolderId) {
-    const [existingFile] = await db
-      .select({ id: workspaceFiles.id })
-      .from(workspaceFiles)
-      .where(
-        and(
-          eq(workspaceFiles.folderId, existingFolderId),
-          eq(workspaceFiles.context, 'workspace'),
-          isNull(workspaceFiles.deletedAt)
+    const [[existingFile], [existingSubfolder]] = await Promise.all([
+      db
+        .select({ id: workspaceFiles.id })
+        .from(workspaceFiles)
+        .where(
+          and(
+            eq(workspaceFiles.folderId, existingFolderId),
+            eq(workspaceFiles.context, 'workspace'),
+            isNull(workspaceFiles.deletedAt)
+          )
         )
-      )
-      .limit(1)
-    if (existingFile) {
+        .limit(1),
+      db
+        .select({ id: workspaceFileFolder.id })
+        .from(workspaceFileFolder)
+        .where(
+          and(
+            eq(workspaceFileFolder.parentId, existingFolderId),
+            isNull(workspaceFileFolder.deletedAt)
+          )
+        )
+        .limit(1),
+    ])
+    if (existingFile || existingSubfolder) {
       return {
         success: false,
-        error: `"${fileName}" appears to be already extracted — ${folderPath}/ exists and contains files. List them with glob("${folderPath}/**"). To re-extract, delete that folder first.`,
+        error: `"${fileName}" appears to be already extracted — ${folderPath}/ exists and contains content. List it with glob("${folderPath}/**"). To re-extract, delete that folder first.`,
       }
     }
   }