@lobehub/lobehub 2.1.5 → 2.1.6

package/locales/zh-CN/plugin.json

@@ -1,4 +1,5 @@
 {
+  "arguments.moreParams": "等 {{count}} 个参数",
   "arguments.title": "参数列表",
   "builtins.lobe-agent-builder.apiName.getAvailableModels": "获取可用模型",
   "builtins.lobe-agent-builder.apiName.getAvailableTools": "获取可用技能",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.1.5",
+  "version": "2.1.6",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/packages/builtin-tool-cloud-sandbox/src/ExecutionRuntime/index.ts

@@ -76,13 +76,13 @@ export class CloudSandboxExecutionRuntime {
       const files = result.result?.files || [];
       const state: ListLocalFilesState = { files };
 
-      const content = formatFileList(
-        files.map((f: { isDirectory: boolean; name: string }) => ({
+      const content = formatFileList({
+        directory: args.directoryPath,
+        files: files.map((f: { isDirectory: boolean; name: string }) => ({
           isDirectory: f.isDirectory,
           name: f.name,
         })),
-        args.directoryPath,
-      );
+      });
 
       return {
         content,

package/packages/builtin-tool-local-system/package.json

@@ -5,8 +5,7 @@
   "exports": {
     ".": "./src/index.ts",
     "./client": "./src/client/index.ts",
-    "./executor": "./src/executor/index.ts",
-    "./executionRuntime": "./src/ExecutionRuntime/index.ts"
+    "./executor": "./src/executor/index.ts"
   },
   "main": "./src/index.ts",
   "dependencies": {

package/packages/builtin-tool-local-system/src/client/Inspector/GlobLocalFiles/index.tsx

@@ -2,8 +2,8 @@
 
 import { type GlobFilesParams } from '@lobechat/electron-client-ipc';
 import { type BuiltinInspectorProps } from '@lobechat/types';
-import { createStaticStyles, cssVar, cx } from 'antd-style';
-import { Check, X } from 'lucide-react';
+import { Text } from '@lobehub/ui';
+import { cssVar, cx } from 'antd-style';
 import { memo } from 'react';
 import { useTranslation } from 'react-i18next';
 
@@ -11,13 +11,6 @@ import { highlightTextStyles, inspectorTextStyles, shinyTextStyles } from '@/sty
 
 import { type GlobFilesState } from '../../..';
 
-const styles = createStaticStyles(({ css }) => ({
-  statusIcon: css`
-    margin-block-end: -2px;
-    margin-inline-start: 4px;
-  `,
-}));
-
 export const GlobLocalFilesInspector = memo<BuiltinInspectorProps<GlobFilesParams, GlobFilesState>>(
   ({ args, partialArgs, isArgumentsStreaming, pluginState, isLoading }) => {
     const { t } = useTranslation('plugin');
@@ -41,22 +34,28 @@ export const GlobLocalFilesInspector = memo<BuiltinInspectorProps<GlobFilesParam
       );
     }
 
-    // Check if glob was successful
-    const isSuccess = pluginState?.result?.success;
+    // Check result count
+    const resultCount = pluginState?.result?.total_files ?? 0;
+    const hasResults = resultCount > 0;
 
     return (
       <div className={cx(inspectorTextStyles.root, isLoading && shinyTextStyles.shinyText)}>
-        <span style={{ marginInlineStart: 2 }}>
-          <span>{t('builtins.lobe-local-system.apiName.globLocalFiles')}: </span>
-          {pattern && <span className={highlightTextStyles.primary}>{pattern}</span>}
-          {isLoading ? null : pluginState?.result ? (
-            isSuccess ? (
-              <Check className={styles.statusIcon} color={cssVar.colorSuccess} size={14} />
-            ) : (
-              <X className={styles.statusIcon} color={cssVar.colorError} size={14} />
-            )
-          ) : null}
-        </span>
+        <span>{t('builtins.lobe-local-system.apiName.globLocalFiles')}: </span>
+        {pattern && <span className={highlightTextStyles.primary}>{pattern}</span>}
+        {!isLoading &&
+          pluginState?.result &&
+          (hasResults ? (
+            <span style={{ marginInlineStart: 4 }}>({resultCount})</span>
+          ) : (
+            <Text
+              as={'span'}
+              color={cssVar.colorTextDescription}
+              fontSize={12}
+              style={{ marginInlineStart: 4 }}
+            >
+              ({t('builtins.lobe-local-system.inspector.noResults')})
+            </Text>
+          ))}
       </div>
     );
   },

package/packages/builtin-tool-local-system/src/executor/index.ts

@@ -87,11 +87,20 @@ class LocalSystemExecutor extends BaseExecutor<typeof LocalSystemApiEnum> {
 
   listLocalFiles = async (params: ListLocalFileParams): Promise<BuiltinToolResult> => {
     try {
-      const result: LocalFileItem[] = await localFileService.listLocalFiles(params);
+      const result = await localFileService.listLocalFiles(params);
 
-      const state: LocalFileListState = { listResults: result };
+      const state: LocalFileListState = {
+        listResults: result.files,
+        totalCount: result.totalCount,
+      };
 
-      const content = formatFileList(result, params.path);
+      const content = formatFileList({
+        directory: params.path,
+        files: result.files,
+        sortBy: params.sortBy,
+        sortOrder: params.sortOrder,
+        totalCount: result.totalCount,
+      });
 
       return {
         content,

package/packages/builtin-tool-local-system/src/manifest.ts

@@ -7,14 +7,31 @@ export const LocalSystemManifest: BuiltinToolManifest = {
   api: [
     {
       description:
-        'List files and folders in a specified directory. Input should be a path. Output is a JSON array of file/folder names.',
+        'List files and folders in a specified directory. Returns file/folder names with metadata (size, modified time). Results are sorted by modified time (newest first) by default and limited to 100 items.',
       name: LocalSystemApiName.listLocalFiles,
       parameters: {
         properties: {
+          limit: {
+            default: 100,
+            description: 'Maximum number of items to return (default: 100)',
+            type: 'number',
+          },
           path: {
             description: 'The directory path to list',
             type: 'string',
           },
+          sortBy: {
+            default: 'modifiedTime',
+            description: 'Field to sort by (default: modifiedTime)',
+            enum: ['name', 'modifiedTime', 'createdTime', 'size'],
+            type: 'string',
+          },
+          sortOrder: {
+            default: 'desc',
+            description: 'Sort order (default: desc)',
+            enum: ['asc', 'desc'],
+            type: 'string',
+          },
         },
         required: ['path'],
         type: 'object',

package/packages/builtin-tool-local-system/src/systemRole.ts

@@ -21,7 +21,7 @@ Use these paths when the user refers to these common locations by name (e.g., "m
 You have access to a set of tools to interact with the user's local file system:
 
 **File Operations:**
-1.  **listLocalFiles**: Lists files and directories in a specified path.
+1.  **listLocalFiles**: Lists files and directories in a specified path. Returns metadata including file size and modification time. Results are sorted by modification time (newest first) by default and limited to 100 items.
 2.  **readLocalFile**: Reads the content of a specified file, optionally within a line range. You can read file types such as Word, Excel, PowerPoint, PDF, and plain text files.
 3.  **writeLocalFile**: Write content to a specific file, only support plain text file like \`.text\` or \`.md\`
 4.  **editLocalFile**: Performs exact string replacements in files. Must read the file first before editing.
@@ -50,7 +50,13 @@ You have access to a set of tools to interact with the user's local file system:
 </workflow>
 
 <tool_usage_guidelines>
-- For listing directory contents: Use 'listFiles' with the target directory path.
+- For listing directory contents: Use 'listLocalFiles'. Provide the following parameters:
+    - 'path': The directory path to list.
+    - 'sortBy' (Optional): Field to sort results by. Options: 'name', 'modifiedTime', 'createdTime', 'size'. Defaults to 'modifiedTime'.
+    - 'sortOrder' (Optional): Sort order. Options: 'asc', 'desc'. Defaults to 'desc' (newest/largest first).
+    - 'limit' (Optional): Maximum number of items to return. Defaults to 100.
+    - The response includes file/folder names with metadata (size in bytes, modification time) for each item.
+    - System files (e.g., '.DS_Store', 'Thumbs.db', '$RECYCLE.BIN') are automatically filtered out.
 - For reading a file: Use 'readFile'. Provide the following parameters:
     - 'path': The exact file path.
     - 'loc' (Optional): A two-element array [startLine, endLine] to specify a line range to read (e.g., '[301, 400]' reads lines 301 to 400).

package/packages/builtin-tool-local-system/src/types.ts

@@ -47,6 +47,7 @@ export interface LocalFileSearchState {
 
 export interface LocalFileListState {
   listResults: LocalFileItem[];
+  totalCount: number;
 }
 
 export interface LocalReadFileState {

package/packages/const/src/file.ts

@@ -1,10 +1,20 @@
-export const FILE_UPLOAD_BLACKLIST = [
+/**
+ * System files to be filtered out when listing directory contents
+ */
+export const SYSTEM_FILES_BLACKLIST = [
   '.DS_Store',
   'Thumbs.db',
   'desktop.ini',
   '.localized',
   'ehthumbs.db',
   'ehthumbs_vista.db',
+  '$RECYCLE.BIN',
+  'System Volume Information',
+  '.Spotlight-V100',
+  '.fseventsd',
+  '.Trashes',
 ];
 
+export const FILE_UPLOAD_BLACKLIST = SYSTEM_FILES_BLACKLIST;
+
 export const MAX_UPLOAD_FILE_COUNT = 10;

package/packages/const/src/index.ts

@@ -2,6 +2,7 @@ export * from './currency';
 export * from './desktop';
 export * from './discover';
 export * from './editor';
+export * from './file';
 export * from './klavis';
 export * from './layoutTokens';
 export * from './lobehubSkill';

package/packages/const/src/version.ts

@@ -1,6 +1,6 @@
 import { BRANDING_NAME, ORG_NAME } from '@lobechat/business-const';
 
-import pkg from '@/../package.json';
+import pkg from '../../../package.json';
 
 export const CURRENT_VERSION = pkg.version;
 

package/packages/electron-client-ipc/src/types/localSystem.ts

@@ -16,8 +16,40 @@ export interface LocalFileItem {
   type: string;
 }
 
+export type ListLocalFileSortBy = 'name' | 'modifiedTime' | 'createdTime' | 'size';
+export type ListLocalFileSortOrder = 'asc' | 'desc';
+
 export interface ListLocalFileParams {
+  /**
+   * Maximum number of files to return
+   * @default 100
+   */
+  limit?: number;
+  /**
+   * Directory path to list
+   */
   path: string;
+  /**
+   * Field to sort by
+   * @default 'modifiedTime'
+   */
+  sortBy?: ListLocalFileSortBy;
+  /**
+   * Sort order
+   * @default 'desc'
+   */
+  sortOrder?: ListLocalFileSortOrder;
+}
+
+export interface ListLocalFilesResult {
+  /**
+   * List of files (truncated to limit)
+   */
+  files: LocalFileItem[];
+  /**
+   * Total count of files before truncation
+   */
+  totalCount: number;
 }
 
 export interface MoveLocalFileParams {

package/packages/file-loaders/src/blackList.ts

@@ -1,4 +1,6 @@
-// List of system files/directories to ignore
+/**
+ * System files to be filtered out when listing directory contents
+ */
 export const SYSTEM_FILES_TO_IGNORE = [
   '.DS_Store',
   'Thumbs.db',
@@ -6,4 +8,9 @@ export const SYSTEM_FILES_TO_IGNORE = [
   '.localized',
   'ehthumbs.db',
   'ehthumbs_vista.db',
+  '$RECYCLE.BIN',
+  'System Volume Information',
+  '.Spotlight-V100',
+  '.fseventsd',
+  '.Trashes',
 ];

package/packages/prompts/src/prompts/fileSystem/formatFileList.test.ts

@@ -3,8 +3,158 @@ import { describe, expect, it } from 'vitest';
 import { formatFileList } from './formatFileList';
 
 describe('formatFileList', () => {
+  describe('snapshot tests', () => {
+    it('should match snapshot for complete extended output', () => {
+      const files = [
+        {
+          isDirectory: true,
+          modifiedTime: new Date('2024-01-20T14:30:00'),
+          name: 'Documents',
+          size: 4096,
+        },
+        {
+          isDirectory: true,
+          modifiedTime: new Date('2024-01-18T09:15:00'),
+          name: 'Downloads',
+          size: 4096,
+        },
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-15T11:20:00'),
+          name: 'report.pdf',
+          size: 2457600,
+        },
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-10T16:45:00'),
+          name: 'screenshot.png',
+          size: 1153434,
+        },
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-05T08:30:00'),
+          name: 'notes.txt',
+          size: 2048,
+        },
+      ];
+
+      const result = formatFileList({
+        directory: '/Users/test/Desktop',
+        files,
+        sortBy: 'modifiedTime',
+        sortOrder: 'desc',
+        totalCount: 150,
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        "Found 150 item(s) in /Users/test/Desktop (showing first 5, sorted by modifiedTime desc):
+          [D] Documents                                2024-01-20 14:30      --
+          [D] Downloads                                2024-01-18 09:15      --
+          [F] report.pdf                               2024-01-15 11:20      2.3 MB
+          [F] screenshot.png                           2024-01-10 16:45      1.1 MB
+          [F] notes.txt                                2024-01-05 08:30        2 KB"
+      `);
+    });
+
+    it('should match snapshot for simple output without extended info', () => {
+      const files = [
+        { isDirectory: true, name: 'src' },
+        { isDirectory: true, name: 'dist' },
+        { isDirectory: false, name: 'package.json' },
+        { isDirectory: false, name: 'README.md' },
+        { isDirectory: false, name: 'tsconfig.json' },
+      ];
+
+      const result = formatFileList({ directory: '/project', files });
+
+      expect(result).toMatchInlineSnapshot(`
+        "Found 5 item(s) in /project:
+          [D] src
+          [D] dist
+          [F] package.json
+          [F] README.md
+          [F] tsconfig.json"
+      `);
+    });
+
+    it('should match snapshot for output with sorting info only', () => {
+      const files = [
+        { isDirectory: false, name: 'alpha.txt' },
+        { isDirectory: false, name: 'beta.txt' },
+        { isDirectory: false, name: 'gamma.txt' },
+      ];
+
+      const result = formatFileList({
+        directory: '/test',
+        files,
+        sortBy: 'name',
+        sortOrder: 'asc',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        "Found 3 item(s) in /test (sorted by name asc):
+          [F] alpha.txt
+          [F] beta.txt
+          [F] gamma.txt"
+      `);
+    });
+
+    it('should match snapshot for various file sizes', () => {
+      const files = [
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-01T00:00:00'),
+          name: 'empty.txt',
+          size: 0,
+        },
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-01T00:00:00'),
+          name: 'tiny.txt',
+          size: 512,
+        },
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-01T00:00:00'),
+          name: 'small.txt',
+          size: 1024,
+        },
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-01T00:00:00'),
+          name: 'medium.txt',
+          size: 1048576,
+        },
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-01T00:00:00'),
+          name: 'large.txt',
+          size: 1073741824,
+        },
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-01T00:00:00'),
+          name: 'huge.txt',
+          size: 1099511627776,
+        },
+      ];
+
+      const result = formatFileList({ directory: '/test', files });
+
+      expect(result).toMatchInlineSnapshot(`
+        "Found 6 item(s) in /test:
+          [F] empty.txt                                2024-01-01 00:00         0 B
+          [F] tiny.txt                                 2024-01-01 00:00       512 B
+          [F] small.txt                                2024-01-01 00:00        1 KB
+          [F] medium.txt                               2024-01-01 00:00        1 MB
+          [F] large.txt                                2024-01-01 00:00        1 GB
+          [F] huge.txt                                 2024-01-01 00:00        1 TB"
+      `);
+    });
+  });
+
   it('should format empty directory', () => {
-    const result = formatFileList([], '/home/user');
+    const result = formatFileList({ directory: '/home/user', files: [] });
     expect(result).toMatchInlineSnapshot(`"Directory /home/user is empty"`);
   });
 
@@ -13,7 +163,7 @@ describe('formatFileList', () => {
       { isDirectory: false, name: 'file1.txt' },
       { isDirectory: false, name: 'file2.js' },
     ];
-    const result = formatFileList(files, '/home/user');
+    const result = formatFileList({ directory: '/home/user', files });
     expect(result).toMatchInlineSnapshot(`
       "Found 2 item(s) in /home/user:
         [F] file1.txt
@@ -26,7 +176,7 @@ describe('formatFileList', () => {
       { isDirectory: true, name: 'src' },
       { isDirectory: true, name: 'dist' },
     ];
-    const result = formatFileList(files, '/project');
+    const result = formatFileList({ directory: '/project', files });
     expect(result).toMatchInlineSnapshot(`
       "Found 2 item(s) in /project:
         [D] src
@@ -41,7 +191,7 @@ describe('formatFileList', () => {
       { isDirectory: true, name: 'node_modules' },
       { isDirectory: false, name: 'README.md' },
     ];
-    const result = formatFileList(files, '/project');
+    const result = formatFileList({ directory: '/project', files });
     expect(result).toMatchInlineSnapshot(`
       "Found 4 item(s) in /project:
         [D] src
@@ -53,10 +203,152 @@ describe('formatFileList', () => {
 
   it('should format single item', () => {
     const files = [{ isDirectory: false, name: 'index.ts' }];
-    const result = formatFileList(files, '/src');
+    const result = formatFileList({ directory: '/src', files });
     expect(result).toMatchInlineSnapshot(`
       "Found 1 item(s) in /src:
         [F] index.ts"
     `);
   });
+
+  describe('extended info', () => {
+    it('should format files with size and modified time', () => {
+      const files = [
+        {
+          isDirectory: true,
+          modifiedTime: new Date('2024-01-20T14:30:00'),
+          name: 'src',
+          size: 4096,
+        },
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-18T09:15:00'),
+          name: 'report.pdf',
+          size: 2457600, // 2.4 MB
+        },
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-15T11:20:00'),
+          name: 'screenshot.png',
+          size: 1153434, // ~1.1 MB
+        },
+      ];
+      const result = formatFileList({ directory: '/Users/test/Downloads', files });
+      expect(result).toContain('Found 3 item(s) in /Users/test/Downloads');
+      expect(result).toContain('[D] src');
+      expect(result).toContain('[F] report.pdf');
+      expect(result).toContain('2024-01-20 14:30');
+      expect(result).toContain('2.3 MB');
+    });
+
+    it('should show sorting and limit info in header', () => {
+      const files = [
+        { isDirectory: false, name: 'file1.txt' },
+        { isDirectory: false, name: 'file2.txt' },
+      ];
+      const result = formatFileList({
+        directory: '/test',
+        files,
+        sortBy: 'modifiedTime',
+        sortOrder: 'desc',
+        totalCount: 150,
+      });
+      expect(result).toContain('Found 150 item(s)');
+      expect(result).toContain('showing first 2');
+      expect(result).toContain('sorted by modifiedTime desc');
+    });
+
+    it('should not show limit info when not truncated', () => {
+      const files = [
+        { isDirectory: false, name: 'file1.txt' },
+        { isDirectory: false, name: 'file2.txt' },
+      ];
+      const result = formatFileList({
+        directory: '/test',
+        files,
+        sortBy: 'name',
+        sortOrder: 'asc',
+      });
+      expect(result).not.toContain('showing');
+      expect(result).toContain('sorted by name asc');
+    });
+
+    it('should show -- for directory size', () => {
+      const files = [
+        {
+          isDirectory: true,
+          modifiedTime: new Date('2024-01-20T14:30:00'),
+          name: 'my_folder',
+          size: 4096,
+        },
+      ];
+      const result = formatFileList({ directory: '/test', files });
+      expect(result).toContain('--');
+    });
+
+    it('should format various file sizes correctly', () => {
+      const files = [
+        { isDirectory: false, modifiedTime: new Date('2024-01-01'), name: 'zero.txt', size: 0 },
+        { isDirectory: false, modifiedTime: new Date('2024-01-01'), name: 'bytes.txt', size: 500 },
+        { isDirectory: false, modifiedTime: new Date('2024-01-01'), name: 'kb.txt', size: 2048 },
+        { isDirectory: false, modifiedTime: new Date('2024-01-01'), name: 'mb.txt', size: 5242880 },
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-01'),
+          name: 'gb.txt',
+          size: 1073741824,
+        },
+      ];
+      const result = formatFileList({ directory: '/test', files });
+      expect(result).toContain('0 B');
+      expect(result).toContain('500 B');
+      expect(result).toContain('2 KB');
+      expect(result).toContain('5 MB');
+      expect(result).toContain('1 GB');
+    });
+
+    it('should handle files with only size (no modifiedTime)', () => {
+      const files = [{ isDirectory: false, name: 'file.txt', size: 1024 }];
+      const result = formatFileList({ directory: '/test', files });
+      expect(result).toContain('[F] file.txt');
+      expect(result).toContain('1 KB');
+    });
+
+    it('should handle files with only modifiedTime (no size)', () => {
+      const files = [
+        { isDirectory: false, modifiedTime: new Date('2024-06-15T10:30:00'), name: 'file.txt' },
+      ];
+      const result = formatFileList({ directory: '/test', files });
+      expect(result).toContain('[F] file.txt');
+      expect(result).toContain('2024-06-15 10:30');
+    });
+
+    it('should handle long file names', () => {
+      const files = [
+        {
+          isDirectory: false,
+          modifiedTime: new Date('2024-01-01'),
+          name: 'this_is_a_very_long_filename_that_exceeds_normal_length.txt',
+          size: 1024,
+        },
+      ];
+      const result = formatFileList({ directory: '/test', files });
+      expect(result).toContain('this_is_a_very_long_filename_that_exceeds_normal_length.txt');
+    });
+
+    it('should handle options with only totalCount', () => {
+      const files = [{ isDirectory: false, name: 'file.txt' }];
+      const result = formatFileList({ directory: '/test', files, totalCount: 100 });
+      expect(result).toContain('Found 100 item(s)');
+      expect(result).toContain('showing first 1');
+    });
+
+    it('should not show extra info when totalCount equals file count', () => {
+      const files = [
+        { isDirectory: false, name: 'file1.txt' },
+        { isDirectory: false, name: 'file2.txt' },
+      ];
+      const result = formatFileList({ directory: '/test', files, totalCount: 2 });
+      expect(result).not.toContain('showing');
+    });
+  });
 });