fix bug

Author: Sg312

apps/sim/lib/copilot/tools/handlers/workflow/mutations.test.ts

@@ -381,6 +381,30 @@ describe('executeCreateWorkflow billing attribution', () => {
     expect(performCreateWorkflowMock).not.toHaveBeenCalled()
   })
 
+  it('rejects canonically ambiguous workflow-folder VFS paths', async () => {
+    listFoldersMock.mockResolvedValue([
+      { folderId: 'folder-cafe-nfc', folderName: 'Caf\u00e9', parentId: null },
+      { folderId: 'folder-cafe-nfd', folderName: 'Cafe\u0301', parentId: null },
+    ])
+
+    const result = await executeCreateWorkflow(
+      {
+        name: 'Created Workflow',
+        workspaceId: 'workspace-1',
+        folderPath: 'workflows/Caf%C3%A9',
+      },
+      executionContext
+    )
+
+    expect(result).toEqual({
+      success: false,
+      error:
+        'Folder path is ambiguous after canonicalization: workflows/Caf%C3%A9. Rename one of the conflicting folders and retry.',
+    })
+    expect(performCreateWorkflowMock).not.toHaveBeenCalled()
+    expect(workflowAuthzMockFns.mockAssertFolderMutable).not.toHaveBeenCalled()
+  })
+
   it('keeps same-workspace creation and subsequent execution on the immutable payer', async () => {
     const context: ExecutionContext = { ...executionContext, workflowId: '' }
     performCreateWorkflowMock.mockResolvedValue({

apps/sim/lib/copilot/tools/handlers/workflow/mutations.ts

@@ -404,10 +404,9 @@ export async function executeCreateWorkflow(
       if (!relativePath) {
         folderId = null
       } else {
-        folderId = lookupFolderIdByPath(folderPath, await loadFolderPathToIdMap(workspaceId))
-        if (!folderId) {
-          return { success: false, error: `Folder not found at ${folderPath}` }
-        }
+        const target = resolveFolderIdByPath(folderPath, await loadFolderPathIndex(workspaceId))
+        if ('error' in target) return { success: false, error: target.error }
+        folderId = target.folderId
       }
     }
 
@@ -1245,40 +1244,57 @@ function workflowFolderRelativePath(rawPath: string): string {
   return trimmed.startsWith('workflows/') ? trimmed.slice('workflows/'.length) : trimmed
 }
 
+type FolderPathIndex = Map<string, string | null>
+
 /**
- * Load a lookup from each folder's canonical encoded VFS path to its id by
- * inverting the same {@link buildVfsFolderPathMap} the VFS uses to serve folder
- * paths, so a path the agent sees via glob round-trips to the right id. Fetched
- * once per manage_folder call and reused across target + parent resolution.
+ * Load an index from each canonical encoded VFS path to its folder id. A null
+ * value records that multiple folder ids collapse to the same canonical path,
+ * so callers can reject the ambiguous path instead of silently choosing one.
  */
-async function loadFolderPathToIdMap(workspaceId: string): Promise<Map<string, string>> {
-  const byPath = new Map<string, string>()
+async function loadFolderPathIndex(workspaceId: string): Promise<FolderPathIndex> {
+  const byPath: FolderPathIndex = new Map()
   for (const [folderId, encodedPath] of buildVfsFolderPathMap(
     await listFolders(workspaceId)
   ).entries()) {
-    byPath.set(encodedPath, folderId)
+    if (!byPath.has(encodedPath)) {
+      byPath.set(encodedPath, folderId)
+    } else if (byPath.get(encodedPath) !== folderId) {
+      byPath.set(encodedPath, null)
+    }
   }
   return byPath
 }
 
-function lookupFolderIdByPath(rawPath: string, byPath: Map<string, string>): string | null {
+function resolveFolderIdByPath(
+  rawPath: string,
+  byPath: FolderPathIndex,
+  label = 'Folder'
+): { folderId: string } | { error: string } {
   const relative = workflowFolderRelativePath(rawPath)
-  if (!relative) return null
-  return byPath.get(encodeVfsPathSegments(decodeVfsPathSegments(relative))) ?? null
+  if (!relative) return { error: `${label} not found at ${rawPath}` }
+
+  const canonicalPath = encodeVfsPathSegments(decodeVfsPathSegments(relative))
+  if (!byPath.has(canonicalPath)) return { error: `${label} not found at ${rawPath}` }
+
+  const folderId = byPath.get(canonicalPath)
+  if (!folderId) {
+    return {
+      error: `${label} path is ambiguous after canonicalization: ${rawPath}. Rename one of the conflicting folders and retry.`,
+    }
+  }
+  return { folderId }
 }
 
 /** Resolve the folder a manage_folder op targets, preferring folderId over path. */
 async function resolveManageFolderTarget(
   params: ManageFolderParams,
-  getFolderPaths: () => Promise<Map<string, string>>
+  getFolderPaths: () => Promise<FolderPathIndex>
 ): Promise<{ folderId: string } | { error: string }> {
   const directId = typeof params.folderId === 'string' ? params.folderId.trim() : ''
   if (directId) return { folderId: directId }
   const path = typeof params.path === 'string' ? params.path.trim() : ''
   if (!path) return { error: 'Provide the folder path (e.g. "workflows/Marketing") or folderId.' }
-  const folderId = lookupFolderIdByPath(path, await getFolderPaths())
-  if (!folderId) return { error: `Folder not found at ${path}` }
-  return { folderId }
+  return resolveFolderIdByPath(path, await getFolderPaths())
 }
 
 /**
@@ -1288,16 +1304,16 @@ async function resolveManageFolderTarget(
  */
 async function resolveManageFolderParent(
   params: ManageFolderParams,
-  getFolderPaths: () => Promise<Map<string, string>>
+  getFolderPaths: () => Promise<FolderPathIndex>
 ): Promise<{ parentId: string | null } | { error: string }> {
   const directId = typeof params.parentId === 'string' ? params.parentId.trim() : ''
   if (directId) return { parentId: directId }
   if (params.parentId === null) return { parentId: null }
   const dest = typeof params.destinationPath === 'string' ? params.destinationPath.trim() : ''
   if (!dest || !workflowFolderRelativePath(dest)) return { parentId: null }
-  const parentId = lookupFolderIdByPath(dest, await getFolderPaths())
-  if (!parentId) return { error: `Destination folder not found at ${dest}` }
-  return { parentId }
+  const parent = resolveFolderIdByPath(dest, await getFolderPaths(), 'Destination folder')
+  if ('error' in parent) return parent
+  return { parentId: parent.folderId }
 }
 
 /**
@@ -1317,8 +1333,8 @@ export async function executeManageFolder(
     // Fetch the workspace folder list at most once, lazily — only when a path
     // (vs an explicit id) actually needs resolving, and shared across the
     // target + parent lookups a single move/create performs.
-    let folderPathsPromise: Promise<Map<string, string>> | undefined
-    const getFolderPaths = () => (folderPathsPromise ??= loadFolderPathToIdMap(workspaceId))
+    let folderPathsPromise: Promise<FolderPathIndex> | undefined
+    const getFolderPaths = () => (folderPathsPromise ??= loadFolderPathIndex(workspaceId))
 
     switch (operation) {
       case 'create': {
@@ -1333,14 +1349,13 @@ export async function executeManageFolder(
           name = segments[segments.length - 1]
           const parentSegments = segments.slice(0, -1)
           if (parentSegments.length > 0) {
-            const resolved = lookupFolderIdByPath(
+            const parent = resolveFolderIdByPath(
               encodeVfsPathSegments(parentSegments),
-              await getFolderPaths()
+              await getFolderPaths(),
+              'Parent folder'
             )
-            if (!resolved) {
-              return { success: false, error: `Parent folder not found for ${path}` }
-            }
-            parentId = resolved
+            if ('error' in parent) return { success: false, error: parent.error }
+            parentId = parent.folderId
           }
         } else {
           const parent = await resolveManageFolderParent(params, getFolderPaths)