@lobehub/lobehub 2.0.0-next.249 → 2.0.0-next.250

package/src/features/ResourceManager/components/Tree/index.tsx

@@ -20,6 +20,7 @@ import { useResourceManagerStore } from '@/app/[variants]/(main)/resource/featur
 import FileIcon from '@/components/FileIcon';
 import { fileService } from '@/services/file';
 import { useFileStore } from '@/store/file';
+import type { ResourceItem } from '@/types/resource';
 
 import { useFileItemDropdown } from '../Explorer/ItemDropdown/useFileItemDropdown';
 import TreeSkeleton from './TreeSkeleton';
@@ -35,6 +36,17 @@ const treeState = new Map<
   }
 >();
 
+const TREE_REFRESH_EVENT = 'resource-tree-refresh';
+
+const emitTreeRefresh = (knowledgeBaseId: string) => {
+  if (typeof window === 'undefined') return;
+  window.dispatchEvent(
+    new CustomEvent(TREE_REFRESH_EVENT, {
+      detail: { knowledgeBaseId },
+    }),
+  );
+};
+
 const getTreeState = (knowledgeBaseId: string) => {
   if (!treeState.has(knowledgeBaseId)) {
     treeState.set(knowledgeBaseId, {
@@ -56,6 +68,47 @@ export const clearTreeFolderCache = async (knowledgeBaseId: string) => {
   const state = treeState.get(knowledgeBaseId);
   if (!state) return;
 
+  const { resourceList } = useFileStore.getState();
+
+  const resolveParentId = (key: string | null | undefined) => {
+    if (!key) return null;
+    // Prefer id match
+    const byId = resourceList.find(
+      (item) => item.knowledgeBaseId === knowledgeBaseId && item.id === key,
+    );
+    if (byId) return byId.id;
+    // Fallback to slug match
+    const bySlug = resourceList.find(
+      (item) => item.knowledgeBaseId === knowledgeBaseId && item.slug === key,
+    );
+    return bySlug?.id ?? key;
+  };
+
+  const buildChildrenFromStore = (parentKey: string | null) => {
+    const parentId = resolveParentId(parentKey);
+    return resourceList
+      .filter(
+        (item) =>
+          item.knowledgeBaseId === knowledgeBaseId &&
+          (item.parentId ?? null) === (parentId ?? null),
+      )
+      .map<ResourceItem>((item) => item)
+      .map((item) => ({
+        fileType: item.fileType,
+        id: item.id,
+        isFolder: item.fileType === 'custom/folder',
+        name: item.name,
+        slug: item.slug,
+        sourceType: item.sourceType,
+        url: item.url || '',
+      }))
+      .sort((a, b) => {
+        if (a.isFolder && !b.isFolder) return -1;
+        if (!a.isFolder && b.isFolder) return 1;
+        return a.name.localeCompare(b.name);
+      });
+  };
+
   // Get list of all currently expanded folders before clearing
   const expandedFoldersList = Array.from(state.expandedFolders);
 
@@ -65,9 +118,16 @@ export const clearTreeFolderCache = async (knowledgeBaseId: string) => {
 
   // Reload each expanded folder
   for (const folderKey of expandedFoldersList) {
+    // Prefer local store (explorer data) to avoid stale remote state
+    const localChildren = buildChildrenFromStore(folderKey);
+    if (localChildren.length > 0) {
+      state.folderChildrenCache.set(folderKey, localChildren);
+      state.loadedFolders.add(folderKey);
+      continue;
+    }
+
+    // Fallback to remote fetch if store has no data (e.g., initial load)
     try {
-      // The API expects document ID, but folderKey could be slug or ID
-      // We'll use it as is and let the API handle it
       const response = await fileService.getKnowledgeItems({
         knowledgeBaseId,
         parentId: folderKey,
@@ -92,7 +152,6 @@ export const clearTreeFolderCache = async (knowledgeBaseId: string) => {
           return a.name.localeCompare(b.name);
         });
 
-        // Update cache using the same key that was used before
         state.folderChildrenCache.set(folderKey, sortedChildren);
         state.loadedFolders.add(folderKey);
       }
@@ -100,6 +159,33 @@ export const clearTreeFolderCache = async (knowledgeBaseId: string) => {
       console.error(`Failed to reload folder ${folderKey}:`, error);
     }
   }
+
+  // Revalidate SWR caches for root and expanded folders to keep list and tree in sync
+  try {
+    const { mutate } = await import('swr');
+    const revalidateFolder = (parentId: string | null) =>
+      mutate(
+        [
+          'useFetchKnowledgeItems',
+          {
+            knowledgeBaseId,
+            parentId,
+            showFilesInKnowledgeBase: false,
+          },
+        ],
+        undefined,
+        { revalidate: true },
+      );
+
+    await Promise.all([
+      revalidateFolder(null),
+      ...expandedFoldersList.map((folderKey) => revalidateFolder(folderKey)),
+    ]);
+  } catch (error) {
+    console.error('Failed to revalidate tree SWR cache:', error);
+  }
+
+  emitTreeRefresh(knowledgeBaseId);
 };
 
 const styles = createStaticStyles(({ css, cssVar }) => ({
@@ -201,13 +287,16 @@ const FileTreeRow = memo<{
 
       try {
         await renameFolder(item.id, renamingValue.trim());
+        if (libraryId) {
+          await clearTreeFolderCache(libraryId);
+        }
         message.success('Renamed successfully');
         setIsRenaming(false);
       } catch (error) {
         console.error('Rename error:', error);
         message.error('Rename failed');
       }
-    }, [item.id, item.name, renamingValue, renameFolder, message]);
+    }, [item.id, item.name, libraryId, renamingValue, renameFolder, message]);
 
     const handleRenameCancel = useCallback(() => {
       setIsRenaming(false);
@@ -218,7 +307,7 @@ const FileTreeRow = memo<{
       fileType: item.fileType,
       filename: item.name,
       id: item.id,
-      knowledgeBaseId: libraryId,
+      libraryId,
       onRenameStart: item.isFolder ? handleRenameStart : undefined,
       sourceType: item.sourceType,
       url: item.url,
@@ -659,6 +748,22 @@ const FileTree = memo(() => {
     parentFolderKeyRef.current = null;
   }, [libraryId]);
 
+  // Listen for external tree refresh events (triggered when cache is cleared)
+  React.useEffect(() => {
+    if (typeof window === 'undefined') return;
+
+    const handleTreeRefresh = (event: Event) => {
+      const detail = (event as CustomEvent<{ knowledgeBaseId?: string }>).detail;
+      if (detail?.knowledgeBaseId && libraryId && detail.knowledgeBaseId !== libraryId) return;
+      forceUpdate();
+    };
+
+    window.addEventListener(TREE_REFRESH_EVENT, handleTreeRefresh);
+    return () => {
+      window.removeEventListener(TREE_REFRESH_EVENT, handleTreeRefresh);
+    };
+  }, [libraryId, forceUpdate]);
+
   // Auto-expand folders when navigating to a folder in Explorer
   React.useEffect(() => {
     if (!folderBreadcrumb || folderBreadcrumb.length === 0) return;

package/src/features/ResourceManager/components/UploadDock/index.tsx

@@ -50,10 +50,11 @@ const styles = createStaticStyles(({ css }) => {
 
 const UploadDock = memo(() => {
   const { t } = useTranslation('file');
-  const [expand, setExpand] = useState(true);
   const [show, setShow] = useState(true);
 
   const dispatchDockFileList = useFileStore((s) => s.dispatchDockFileList);
+  const expand = useFileStore((s) => s.uploadDockExpanded);
+  const setExpand = useFileStore((s) => s.setUploadDockExpanded);
   const totalUploadingProgress = useFileStore(fileManagerSelectors.overviewUploadingProgress);
   const fileList = useFileStore(fileManagerSelectors.dockFileList, isEqual);
   const overviewUploadingStatus = useFileStore(

package/src/features/ResourceManager/constants.ts

@@ -0,0 +1,3 @@
+const PAGE_FILE_TYPE = 'custom/document';
+
+export { PAGE_FILE_TYPE };

package/src/hooks/useMCPCategory.tsx

@@ -2,6 +2,7 @@ import {
   BriefcaseIcon,
   CheckSquareIcon,
   CloudIcon,
+  CompassIcon,
   CodeIcon,
   CoffeeIcon,
   DollarSignIcon,
@@ -25,6 +26,12 @@ export const useCategory = () => {
   const { t } = useTranslation('discover');
   return useMemo(
     () => [
+      {
+        icon: CompassIcon,
+        key: McpCategory.Discover,
+        label: t('mcp.categories.discover.name'),
+        title: t('mcp.categories.discover.description'),
+      },
       {
         icon: LayoutPanelTopIcon,
         key: McpCategory.All,

package/src/locales/default/discover.ts

@@ -165,6 +165,8 @@ export default {
   'mcp.categories.business.name': 'Business Services',
   'mcp.categories.developer.description': 'Developer-related Tools and Services',
   'mcp.categories.developer.name': 'Developer Tools',
+  'mcp.categories.discover.description': 'Recommended and trending MCP servers',
+  'mcp.categories.discover.name': 'Discover',
   'mcp.categories.gaming-entertainment.description': 'Games, Entertainment, and Leisure Activities',
   'mcp.categories.gaming-entertainment.name': 'Gaming & Entertainment',
   'mcp.categories.health-wellness.description': 'Health, Fitness, and Wellness',
@@ -380,6 +382,7 @@ export default {
   'mcp.sorts.isValidated': 'Validated Skills',
   'mcp.sorts.promptsCount': 'Number of Prompts',
   'mcp.sorts.ratingCount': 'Number of Ratings',
+  'mcp.sorts.recommended': 'Recommended',
   'mcp.sorts.resourcesCount': 'Number of Resources',
   'mcp.sorts.toolsCount': 'Number of Tools',
   'mcp.sorts.updatedAt': 'Recently Updated',

package/src/locales/default/file.ts

@@ -18,6 +18,8 @@ export default {
   'empty': 'No files or folders have been uploaded yet.',
   'header.actions.builtInBlockList.filtered': '{{ignored}} files filtered (out of {{total}} total)',
   'header.actions.connect': 'Connect...',
+  'header.actions.createFolderError': 'Failed to create folder',
+  'header.actions.creatingFolder': 'Creating folder...',
   'header.actions.gitignore.apply': 'Apply Rules',
   'header.actions.gitignore.cancel': 'Ignore Rules',
   'header.actions.gitignore.content':

package/src/services/file/index.ts

@@ -2,6 +2,7 @@ import { lambdaClient } from '@/libs/trpc/client';
 import {
   type CheckFileHashResult,
   type FileItem,
+  type FileListItem,
   type QueryFileListParams,
   type QueryFileListSchemaType,
   type UploadFileParams,
@@ -58,8 +59,40 @@ export class FileService {
   };
 
   // V2.0 Migrate from getFileItem to getKnowledgeItem
+  // This method handles both files (file_ prefix) and documents (docs_ prefix)
   getKnowledgeItem = async (id: string) => {
-    return lambdaClient.file.getFileItemById.query({ id });
+    // Detect type based on ID prefix
+    if (id.startsWith('docs_')) {
+      // Document (including folders) - use document endpoint
+      const doc = await lambdaClient.document.getDocumentById.query({ id });
+      if (!doc) return null;
+      
+      // Convert document to FileListItem format
+      return {
+        chunkCount: null,
+        chunkingError: null,
+        chunkingStatus: null,
+        content: doc.content,
+        createdAt: doc.createdAt ? new Date(doc.createdAt) : new Date(),
+        editorData: doc.editorData,
+        embeddingError: null,
+        embeddingStatus: null,
+        fileType: doc.fileType || 'custom/document',
+        finishEmbedding: false,
+        id: doc.id,
+        metadata: doc.metadata,
+        name: doc.title || doc.filename || 'Untitled',
+        parentId: doc.parentId,
+        size: doc.totalCharCount || 0,
+        slug: doc.slug,
+        sourceType: 'document',
+        updatedAt: doc.updatedAt ? new Date(doc.updatedAt) : new Date(),
+        url: doc.source || '',
+      } as FileListItem;
+    } else {
+      // File - use dedicated file endpoint
+      return lambdaClient.file.getFileItemById.query({ id });
+    }
   };
 
   getFolderBreadcrumb = async (slug: string) => {

package/src/services/resource/index.ts

@@ -0,0 +1,249 @@
+import type { FileListItem } from '@/types/files';
+import type {
+  CreateResourceParams,
+  ResourceItem,
+  ResourceQueryParams,
+  UpdateResourceParams,
+} from '@/types/resource';
+
+import { type CreateDocumentParams, documentService } from '../document';
+import { fileService } from '../file';
+
+/**
+ * Map FileListItem to ResourceItem
+ */
+const mapToResourceItem = (item: FileListItem): ResourceItem => {
+  return {
+    chunkCount: item.chunkCount,
+    chunkTaskId: item.chunkingStatus ? 'placeholder' : null,
+    chunkingError: item.chunkingError,
+    chunkingStatus: item.chunkingStatus,
+    // Document-specific fields
+    content: item.content,
+
+    createdAt: item.createdAt,
+
+    editorData: item.editorData,
+
+    embeddingError: item.embeddingError,
+
+    embeddingStatus: item.embeddingStatus,
+
+    embeddingTaskId: item.embeddingStatus ? 'placeholder' : null,
+
+    fileType: item.fileType,
+
+    finishEmbedding: item.finishEmbedding,
+
+    id: item.id,
+
+    // Metadata
+    metadata: item.metadata || undefined,
+
+    name: item.name,
+
+    parentId: item.parentId,
+
+    size: item.size,
+
+    slug: item.slug,
+
+    sourceType: item.sourceType as 'file' | 'document',
+
+    updatedAt: item.updatedAt,
+
+    // File-specific fields
+    url: item.url,
+  };
+};
+
+/**
+ * ResourceService - Unified service for both files and documents
+ * Provides a thin wrapper over FileService and DocumentService
+ * Used by ResourceManager for optimistic updates
+ */
+export class ResourceService {
+  /**
+   * Query resources (unified files + documents)
+   * Uses KnowledgeRepo UNION ALL query
+   */
+  async queryResources(params: ResourceQueryParams): Promise<{
+    hasMore: boolean;
+    items: ResourceItem[];
+    total?: number;
+  }> {
+    // Map frontend parameter names to backend parameter names
+    const backendParams = {
+      ...params,
+      knowledgeBaseId: params.libraryId, // Map libraryId to knowledgeBaseId
+      libraryId: undefined, // Remove the frontend-specific parameter
+    };
+
+    const response = await fileService.getKnowledgeItems(backendParams);
+
+    return {
+      hasMore: response.hasMore,
+      items: response.items.map(mapToResourceItem),
+      total: 'total' in response ? (response.total as number) : undefined,
+    };
+  }
+
+  /**
+   * Get a single resource by ID
+   */
+  async getResource(id: string): Promise<ResourceItem | undefined> {
+    const item = await fileService.getKnowledgeItem(id);
+    return item ? mapToResourceItem(item) : undefined;
+  }
+
+  /**
+   * Create a new resource (file or document)
+   */
+  async createResource(params: CreateResourceParams): Promise<ResourceItem> {
+    if (params.sourceType === 'file') {
+      // Create file
+      const result = await fileService.createFile(
+        {
+          fileType: params.fileType,
+          name: params.name,
+          parentId: params.parentId,
+          size: params.size,
+          url: params.url,
+        },
+        params.knowledgeBaseId,
+      );
+
+      // Fetch the created file to get full details
+      const created = await fileService.getKnowledgeItem(result.id);
+      if (!created) throw new Error('Failed to fetch created file');
+
+      return mapToResourceItem(created);
+    } else {
+      // Create document
+      const documentParams: CreateDocumentParams = {
+        content: params.content || '',
+        editorData: JSON.stringify(params.editorData || {}),
+        fileType: params.fileType,
+        knowledgeBaseId: params.knowledgeBaseId,
+        metadata: params.metadata,
+        parentId: params.parentId,
+        slug: params.slug,
+        title: params.title,
+      };
+
+      const created = await documentService.createDocument(documentParams);
+
+      // Map to ResourceItem
+      return {
+        content: created.content,
+        createdAt: created.createdAt ? new Date(created.createdAt) : new Date(),
+        editorData:
+          typeof created.editorData === 'string'
+            ? JSON.parse(created.editorData)
+            : created.editorData,
+        fileType: created.fileType || 'custom/document',
+        id: created.id,
+        metadata: created.metadata || undefined,
+        name: created.title || 'Untitled',
+        parentId: created.parentId,
+        size: created.totalCharCount || 0,
+        slug: created.slug || undefined,
+        sourceType: 'document',
+        title: created.title || undefined,
+        updatedAt: created.updatedAt ? new Date(created.updatedAt) : new Date(),
+        url: created.source || '',
+      };
+    }
+  }
+
+  /**
+   * Update a resource
+   */
+  async updateResource(id: string, updates: UpdateResourceParams): Promise<ResourceItem> {
+    // Check if this is a file or document by fetching it first
+    const existing = await this.getResource(id);
+    if (!existing) throw new Error('Resource not found');
+
+    if (existing.sourceType === 'file') {
+      // Update file (currently only supports parentId)
+      if (updates.parentId !== undefined) {
+        await fileService.updateFile(id, { parentId: updates.parentId });
+      }
+
+      // Fetch updated file
+      const updated = await fileService.getKnowledgeItem(id);
+      if (!updated) throw new Error('Failed to fetch updated file');
+
+      return mapToResourceItem(updated);
+    } else {
+      // Update document
+      await documentService.updateDocument({
+        content: updates.content,
+        editorData: updates.editorData ? JSON.stringify(updates.editorData) : undefined,
+        id,
+        metadata: updates.metadata,
+        // Keep null as null (for moving to root), don't convert to undefined
+        parentId: updates.parentId !== undefined ? updates.parentId : undefined,
+        title: updates.title || updates.name,
+      });
+
+      // Fetch updated document
+      const updated = await fileService.getKnowledgeItem(id);
+      if (!updated) throw new Error('Failed to fetch updated document');
+
+      return mapToResourceItem(updated);
+    }
+  }
+
+  /**
+   * Delete a resource
+   */
+  async deleteResource(id: string): Promise<void> {
+    // Check if this is a file or document
+    const existing = await this.getResource(id);
+    if (!existing) return; // Already deleted
+
+    if (existing.sourceType === 'file') {
+      await fileService.removeFile(id);
+    } else {
+      await documentService.deleteDocument(id);
+    }
+  }
+
+  /**
+   * Batch delete resources
+   */
+  async deleteResources(ids: string[]): Promise<void> {
+    // Separate files and documents
+    const fileIds: string[] = [];
+    const documentIds: string[] = [];
+
+    await Promise.all(
+      ids.map(async (id) => {
+        const item = await this.getResource(id);
+        if (item) {
+          if (item.sourceType === 'file') {
+            fileIds.push(id);
+          } else {
+            documentIds.push(id);
+          }
+        }
+      }),
+    );
+
+    // Batch delete
+    await Promise.all([
+      fileIds.length > 0 ? fileService.removeFiles(fileIds) : Promise.resolve(),
+      documentIds.length > 0 ? documentService.deleteDocuments(documentIds) : Promise.resolve(),
+    ]);
+  }
+
+  /**
+   * Move a resource to a different parent folder
+   */
+  async moveResource(id: string, parentId: string | null): Promise<ResourceItem> {
+    return this.updateResource(id, { parentId });
+  }
+}
+
+export const resourceService = new ResourceService();

package/src/store/discover/slices/mcp/action.ts

@@ -36,7 +36,7 @@ export const createMCPSlice: StateCreator<
     );
   },
 
-  useFetchMcpList: (params: any) => {
+  useFetchMcpList: (params) => {
     const locale = globalHelpers.getCurrentLanguage();
     return useClientDataSWR(
       ['mcp-list', locale, ...Object.values(params)].filter(Boolean).join('-'),

package/src/store/file/slices/chat/action.ts

@@ -88,7 +88,8 @@ export const createFileSlice: StateCreator<
       let fileItem: FileListItem | undefined = undefined;
 
       try {
-        fileItem = await fileService.getKnowledgeItem(id);
+        const result = await fileService.getKnowledgeItem(id);
+        fileItem = result ?? undefined;
       } catch (e) {
         console.error('getFileItem Error:', e);
         continue;

package/src/store/file/slices/document/action.ts

@@ -194,9 +194,9 @@ export const createDocumentSlice: StateCreator<
       title: name,
     });
 
-    // Refresh file list to show the new folder
-    // Note: refreshFileList now keeps cache to avoid skeleton flash
-    await get().refreshFileList();
+    // Refetch resource list to show the new folder
+    const { revalidateResources } = await import('../resource/hooks');
+    await revalidateResources();
 
     return folder.id;
   },
@@ -641,7 +641,10 @@ export const createDocumentSlice: StateCreator<
       parentId: updates.parentId !== undefined ? updates.parentId : undefined,
       title: updates.title,
     });
-    await get().refreshFileList();
+
+    // Refetch resource list to show updated document
+    const { revalidateResources } = await import('../resource/hooks');
+    await revalidateResources();
   },
 
   updateDocumentOptimistically: async (documentId, updates) => {
@@ -697,9 +700,9 @@ export const createDocumentSlice: StateCreator<
         title: updatedPage.title || updatedPage.filename,
       });
 
-      // After successful sync, refresh file list to get server state
-      // This will eventually sync back to the map via syncDocumentMapWithServer
-      await get().refreshFileList();
+      // After successful sync, refetch resources to get server state
+      const { revalidateResources } = await import('../resource/hooks');
+      await revalidateResources();
     } catch (error) {
       console.error('[updateDocumentOptimistically] Failed to sync to DB:', error);
       // On error, revert the optimistic update

package/src/store/file/slices/fileManager/action.ts

@@ -45,6 +45,10 @@ export interface FileManageAction {
 
   reEmbeddingChunks: (id: string) => Promise<void>;
   reParseFile: (id: string) => Promise<void>;
+  /**
+   * @deprecated Use fetchResources(queryParams) from resource slice instead
+   * This method is kept for backward compatibility with non-ResourceManager code
+   */
   refreshFileList: () => Promise<void>;
   removeAllFiles: () => Promise<void>;
   removeFileItem: (id: string) => Promise<void>;
@@ -53,6 +57,7 @@ export interface FileManageAction {
 
   setCurrentFolderId: (folderId: string | null | undefined) => void;
   setPendingRenameItemId: (id: string | null) => void;
+  setUploadDockExpanded: (expanded: boolean) => void;
 
   toggleEmbeddingIds: (ids: string[], loading?: boolean) => void;
   toggleParsingIds: (ids: string[], loading?: boolean) => void;
@@ -252,7 +257,7 @@ export const createFileManageSlice: StateCreator<
       { concurrency: MAX_UPLOAD_FILE_COUNT },
     );
 
-    // Refresh the file list once after all uploads are complete
+    // Refresh file list to show newly uploaded files
     await get().refreshFileList();
 
     // 5. auto-embed files that support chunking
@@ -349,6 +354,10 @@ export const createFileManageSlice: StateCreator<
     set({ pendingRenameItemId: id }, false, 'setPendingRenameItemId');
   },
 
+  setUploadDockExpanded: (expanded) => {
+    set({ uploadDockExpanded: expanded }, false, 'setUploadDockExpanded');
+  },
+
   toggleEmbeddingIds: (ids, loading) => {
     set((state) => {
       const nextValue = new Set(state.creatingEmbeddingTaskIds);
@@ -534,9 +543,10 @@ export const createFileManageSlice: StateCreator<
     }),
 
   useFetchKnowledgeItem: (id) =>
-    useClientDataSWR<FileListItem | undefined>(!id ? null : ['useFetchKnowledgeItem', id], () =>
-      serverFileService.getKnowledgeItem(id!),
-    ),
+    useClientDataSWR<FileListItem | undefined>(!id ? null : ['useFetchKnowledgeItem', id], async () => {
+      const response = await serverFileService.getKnowledgeItem(id!);
+      return response ?? undefined;
+    }),
 
   useFetchKnowledgeItems: (params) =>
     useClientDataSWR<FileListItem[]>([FETCH_ALL_KNOWLEDGE_KEY, params], async () => {

package/src/store/file/slices/fileManager/initialState.ts

@@ -12,6 +12,7 @@ export interface FileManagerState {
   fileListOffset: number;
   pendingRenameItemId: string | null;
   queryListParams?: QueryFileListParams;
+  uploadDockExpanded: boolean;
 }
 
 export const initialFileManagerState: FileManagerState = {
@@ -23,4 +24,5 @@ export const initialFileManagerState: FileManagerState = {
   fileListHasMore: false,
   fileListOffset: 0,
   pendingRenameItemId: null,
+  uploadDockExpanded: true,
 };