@lobehub/lobehub 2.0.0-next.73 → 2.0.0-next.75

package/src/tools/local-system/ExecutionRuntime/index.ts

@@ -0,0 +1,407 @@
+import {
+  EditLocalFileParams,
+  EditLocalFileResult,
+  GetCommandOutputParams,
+  GetCommandOutputResult,
+  GlobFilesParams,
+  GlobFilesResult,
+  GrepContentParams,
+  GrepContentResult,
+  KillCommandParams,
+  KillCommandResult,
+  ListLocalFileParams,
+  LocalFileItem,
+  LocalMoveFilesResultItem,
+  LocalReadFileParams,
+  LocalReadFileResult,
+  LocalReadFilesParams,
+  LocalSearchFilesParams,
+  MoveLocalFilesParams,
+  RenameLocalFileParams,
+  RenameLocalFileResult,
+  RunCommandParams,
+  RunCommandResult,
+  WriteLocalFileParams,
+} from '@lobechat/electron-client-ipc';
+import { BuiltinServerRuntimeOutput } from '@lobechat/types';
+
+import { localFileService } from '@/services/electron/localFileService';
+
+import {
+  EditLocalFileState,
+  GetCommandOutputState,
+  GlobFilesState,
+  GrepContentState,
+  KillCommandState,
+  LocalFileListState,
+  LocalFileSearchState,
+  LocalMoveFilesState,
+  LocalReadFileState,
+  LocalReadFilesState,
+  LocalRenameFileState,
+  RunCommandState,
+} from '../type';
+
+export class LocalSystemExecutionRuntime {
+  // ==================== File Operations ====================
+
+  async listLocalFiles(args: ListLocalFileParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const result: LocalFileItem[] = await localFileService.listLocalFiles(args);
+
+      const state: LocalFileListState = { listResults: result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  async readLocalFile(args: LocalReadFileParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const result: LocalReadFileResult = await localFileService.readLocalFile(args);
+
+      const state: LocalReadFileState = { fileContent: result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  async readLocalFiles(args: LocalReadFilesParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const results: LocalReadFileResult[] = await localFileService.readLocalFiles(args);
+
+      const state: LocalReadFilesState = { filesContent: results };
+
+      return {
+        content: JSON.stringify(results),
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  async searchLocalFiles(args: LocalSearchFilesParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const result: LocalFileItem[] = await localFileService.searchLocalFiles(args);
+
+      const state: LocalFileSearchState = { searchResults: result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  async moveLocalFiles(args: MoveLocalFilesParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const results: LocalMoveFilesResultItem[] = await localFileService.moveLocalFiles(args);
+
+      const allSucceeded = results.every((r) => r.success);
+      const someFailed = results.some((r) => !r.success);
+      const successCount = results.filter((r) => r.success).length;
+      const failedCount = results.length - successCount;
+
+      let message = '';
+
+      if (allSucceeded) {
+        message = `Successfully moved ${results.length} item(s).`;
+      } else if (someFailed) {
+        message = `Moved ${successCount} item(s) successfully. Failed to move ${failedCount} item(s).`;
+      } else {
+        message = `Failed to move all ${results.length} item(s).`;
+      }
+
+      const state: LocalMoveFilesState = {
+        results,
+        successCount,
+        totalCount: results.length,
+      };
+
+      return {
+        content: JSON.stringify({ message, results }),
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  async renameLocalFile(args: RenameLocalFileParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const result: RenameLocalFileResult = await localFileService.renameLocalFile(args);
+
+      if (!result.success) {
+        const state: LocalRenameFileState = {
+          error: result.error,
+          newPath: '',
+          oldPath: args.path,
+          success: false,
+        };
+
+        return {
+          content: JSON.stringify({ message: result.error, success: false }),
+          state,
+          success: false,
+        };
+      }
+
+      const state: LocalRenameFileState = {
+        newPath: result.newPath!,
+        oldPath: args.path,
+        success: true,
+      };
+
+      return {
+        content: JSON.stringify({
+          message: `Successfully renamed file ${args.path} to ${args.newName}.`,
+          success: true,
+        }),
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  async writeLocalFile(args: WriteLocalFileParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const result = await localFileService.writeFile(args);
+
+      if (!result.success) {
+        return {
+          content: JSON.stringify({
+            message: result.error || '写入文件失败',
+            success: false,
+          }),
+          error: result.error,
+          success: false,
+        };
+      }
+
+      return {
+        content: JSON.stringify({
+          message: `成功写入文件 ${args.path}`,
+          success: true,
+        }),
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  async editLocalFile(args: EditLocalFileParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const result: EditLocalFileResult = await localFileService.editLocalFile(args);
+
+      if (!result.success) {
+        return {
+          content: `Edit failed: ${result.error}`,
+          success: false,
+        };
+      }
+
+      const statsText =
+        result.linesAdded || result.linesDeleted
+          ? ` (+${result.linesAdded || 0} -${result.linesDeleted || 0})`
+          : '';
+      const message = `Successfully replaced ${result.replacements} occurrence(s) in ${args.file_path}${statsText}`;
+
+      const state: EditLocalFileState = {
+        diffText: result.diffText,
+        linesAdded: result.linesAdded,
+        linesDeleted: result.linesDeleted,
+        replacements: result.replacements,
+      };
+
+      return {
+        content: message,
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  // ==================== Shell Commands ====================
+
+  async runCommand(args: RunCommandParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const result: RunCommandResult = await localFileService.runCommand(args);
+
+      let message: string;
+
+      if (result.success) {
+        if (result.shell_id) {
+          message = `Command started in background with shell_id: ${result.shell_id}`;
+        } else {
+          message = `Command completed successfully.`;
+        }
+      } else {
+        message = `Command failed: ${result.error}`;
+      }
+
+      const state: RunCommandState = { message, result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: result.success,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  async getCommandOutput(args: GetCommandOutputParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const result: GetCommandOutputResult = await localFileService.getCommandOutput(args);
+
+      const message = result.success
+        ? `Output retrieved. Running: ${result.running}`
+        : `Failed: ${result.error}`;
+
+      const state: GetCommandOutputState = { message, result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: result.success,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  async killCommand(args: KillCommandParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const result: KillCommandResult = await localFileService.killCommand(args);
+
+      const message = result.success
+        ? `Successfully killed shell: ${args.shell_id}`
+        : `Failed to kill shell: ${result.error}`;
+
+      const state: KillCommandState = { message, result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: result.success,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  // ==================== Search & Find ====================
+
+  async grepContent(args: GrepContentParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const result: GrepContentResult = await localFileService.grepContent(args);
+
+      const message = result.success
+        ? `Found ${result.total_matches} matches in ${result.matches.length} locations`
+        : 'Search failed';
+
+      const state: GrepContentState = { message, result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: result.success,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  async globLocalFiles(args: GlobFilesParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const result: GlobFilesResult = await localFileService.globFiles(args);
+
+      const message = result.success ? `Found ${result.total_files} files` : 'Glob search failed';
+
+      const state: GlobFilesState = { message, result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: result.success,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error,
+        success: false,
+      };
+    }
+  }
+}

package/src/tools/local-system/Intervention/EditLocalFile/index.tsx

@@ -0,0 +1,89 @@
+import { EditLocalFileParams } from '@lobechat/electron-client-ipc';
+import { BuiltinInterventionProps } from '@lobechat/types';
+import { Icon, Text } from '@lobehub/ui';
+import { Skeleton } from 'antd';
+import { createPatch } from 'diff';
+import { ChevronRight } from 'lucide-react';
+import path from 'path-browserify-esm';
+import React, { memo, useMemo } from 'react';
+import { Diff, Hunk, parseDiff } from 'react-diff-view';
+import 'react-diff-view/style/index.css';
+import { useTranslation } from 'react-i18next';
+import { Flexbox } from 'react-layout-kit';
+import useSWR from 'swr';
+
+import { LocalFile, LocalFolder } from '@/features/LocalFile';
+import { localFileService } from '@/services/electron/localFileService';
+
+const EditLocalFile = memo<BuiltinInterventionProps<EditLocalFileParams>>(({ args }) => {
+  const { t } = useTranslation('tool');
+  const { base, dir } = path.parse(args.file_path);
+
+  // Fetch full file content
+  const { data: fileData, isLoading } = useSWR(
+    ['readLocalFile', args.file_path],
+    () => localFileService.readLocalFile({ fullContent: true, path: args.file_path }),
+    {
+      revalidateOnFocus: false,
+      revalidateOnReconnect: false,
+    },
+  );
+
+  // Generate diff from full file content
+  const files = useMemo(() => {
+    if (!fileData?.content) return [];
+
+    try {
+      const oldContent = fileData.content;
+
+      // Generate new content by applying the replacement
+      const newContent = args.replace_all
+        ? oldContent.replaceAll(args.old_string, args.new_string)
+        : oldContent.replace(args.old_string, args.new_string);
+
+      // Use createPatch to generate unified diff with full file content
+      const patch = createPatch(args.file_path, oldContent, newContent, '', '');
+
+      // Add git diff header for parseDiff compatibility
+      const diffText = `diff --git a${args.file_path} b${args.file_path}\n${patch}`;
+
+      return parseDiff(diffText);
+    } catch (error) {
+      console.error('Failed to generate diff:', error);
+      return [];
+    }
+  }, [fileData?.content, args.file_path, args.old_string, args.new_string, args.replace_all]);
+
+  return (
+    <Flexbox gap={12}>
+      <Flexbox horizontal>
+        <LocalFolder path={dir} />
+        <Icon icon={ChevronRight} />
+        <LocalFile name={base} path={args.file_path} />
+      </Flexbox>
+
+      {isLoading ? (
+        <Skeleton active paragraph={{ rows: 3 }} />
+      ) : (
+        <Flexbox gap={8}>
+          <Text type="secondary">
+            {args.replace_all
+              ? t('localFiles.editFile.replaceAll')
+              : t('localFiles.editFile.replaceFirst')}
+          </Text>
+          {files.map((file, index) => (
+            <div key={`${file.oldPath}-${index}`} style={{ fontSize: '12px' }}>
+              <Diff diffType={file.type} hunks={file.hunks} viewType="split">
+                {(hunks) => hunks.map((hunk) => <Hunk hunk={hunk} key={hunk.content} />)}
+              </Diff>
+            </div>
+          ))}
+        </Flexbox>
+      )}
+    </Flexbox>
+  );
+});
+
+EditLocalFile.displayName = 'EditLocalFileIntervention';
+
+export default EditLocalFile;

package/src/tools/local-system/Intervention/WriteFile/index.tsx

@@ -0,0 +1,72 @@
+import { WriteLocalFileParams } from '@lobechat/electron-client-ipc';
+import { BuiltinInterventionProps } from '@lobechat/types';
+import { Highlighter, Icon, Text } from '@lobehub/ui';
+import { ChevronRight } from 'lucide-react';
+import path from 'path-browserify-esm';
+import React, { memo, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Flexbox } from 'react-layout-kit';
+
+import { LocalFile, LocalFolder } from '@/features/LocalFile';
+
+const WriteFile = memo<BuiltinInterventionProps<WriteLocalFileParams>>(({ args }) => {
+  const { t } = useTranslation('tool');
+  const { base, dir, ext } = path.parse(args.path);
+
+  // Detect language from file extension
+  const language = useMemo(() => {
+    const extMap: Record<string, string> = {
+      css: 'css',
+      html: 'html',
+      js: 'javascript',
+      json: 'json',
+      jsx: 'jsx',
+      md: 'markdown',
+      py: 'python',
+      sh: 'bash',
+      ts: 'typescript',
+      tsx: 'tsx',
+      txt: 'text',
+      xml: 'xml',
+      yaml: 'yaml',
+      yml: 'yaml',
+    };
+    return extMap[ext.replace('.', '')] || 'text';
+  }, [ext]);
+
+  const contentLength = args.content?.length || 0;
+
+  return (
+    <Flexbox gap={12}>
+      <Flexbox horizontal>
+        <LocalFolder path={dir} />
+        <Icon icon={ChevronRight} />
+        <LocalFile name={base} path={args.path} />
+      </Flexbox>
+
+      <Flexbox gap={4}>
+        <Flexbox horizontal justify={'space-between'}>
+          <Text type="secondary">{t('localFiles.writeFile.preview')}</Text>
+          <Text style={{ fontSize: 12 }} type={'secondary'}>
+            {contentLength.toLocaleString()} {t('localFiles.writeFile.characters')}
+          </Text>
+        </Flexbox>
+
+        {args.content && (
+          <Highlighter
+            language={language}
+            showLanguage={false}
+            style={{ maxHeight: 400, overflow: 'auto', padding: '8px' }}
+            variant={'outlined'}
+          >
+            {args.content}
+          </Highlighter>
+        )}
+      </Flexbox>
+    </Flexbox>
+  );
+});
+
+WriteFile.displayName = 'WriteFileIntervention';
+
+export default WriteFile;

package/src/tools/local-system/Intervention/index.ts

@@ -1,11 +1,15 @@
 import { LocalSystemApiName } from '../index';
+import EditLocalFile from './EditLocalFile';
 import MoveLocalFiles from './MoveLocalFiles';
 import RunCommand from './RunCommand';
+import WriteFile from './WriteFile';
 
 /**
  * Local System Intervention Components Registry
  */
 export const LocalSystemInterventions = {
+  [LocalSystemApiName.editLocalFile]: EditLocalFile,
   [LocalSystemApiName.moveLocalFiles]: MoveLocalFiles,
   [LocalSystemApiName.runCommand]: RunCommand,
+  [LocalSystemApiName.writeLocalFile]: WriteFile,
 };

package/src/tools/local-system/Render/EditLocalFile/index.tsx

@@ -0,0 +1,67 @@
+import { EditLocalFileParams } from '@lobechat/electron-client-ipc';
+import { BuiltinRenderProps } from '@lobechat/types';
+import { Alert, Icon } from '@lobehub/ui';
+import { Skeleton } from 'antd';
+import { ChevronRight } from 'lucide-react';
+import path from 'path-browserify-esm';
+import React, { memo, useMemo } from 'react';
+import { Diff, Hunk, parseDiff } from 'react-diff-view';
+import 'react-diff-view/style/index.css';
+import { Flexbox } from 'react-layout-kit';
+
+import { LocalFile, LocalFolder } from '@/features/LocalFile';
+
+import { EditLocalFileState } from '../../type';
+
+const EditLocalFile = memo<BuiltinRenderProps<EditLocalFileParams, EditLocalFileState>>(
+  ({ args, pluginState, pluginError }) => {
+    const { base, dir } = path.parse(args.file_path);
+
+    // Parse diff for react-diff-view
+    const files = useMemo(() => {
+      const diffText = pluginState?.diffText;
+      if (!diffText) return [];
+
+      try {
+        return parseDiff(diffText);
+      } catch (error) {
+        console.error('Failed to parse diff:', error);
+        return [];
+      }
+    }, [pluginState?.diffText]);
+
+    if (!args) return <Skeleton active />;
+
+    return (
+      <Flexbox gap={12}>
+        <Flexbox horizontal>
+          <LocalFolder path={dir} />
+          <Icon icon={ChevronRight} />
+          <LocalFile name={base} path={args.file_path} />
+        </Flexbox>
+        {pluginError ? (
+          <Alert
+            description={pluginError.message || 'Unknown error occurred'}
+            message="Edit Failed"
+            showIcon
+            type="error"
+          />
+        ) : (
+          <Flexbox gap={12}>
+            {files.map((file, index) => (
+              <div key={`${file.oldPath}-${index}`} style={{ fontSize: '12px' }}>
+                <Diff diffType={file.type} gutterType="default" hunks={file.hunks} viewType="split">
+                  {(hunks) => hunks.map((hunk) => <Hunk hunk={hunk} key={hunk.content} />)}
+                </Diff>
+              </div>
+            ))}
+          </Flexbox>
+        )}
+      </Flexbox>
+    );
+  },
+);
+
+EditLocalFile.displayName = 'EditLocalFile';
+
+export default EditLocalFile;