@lobehub/lobehub 2.0.0-next.50 → 2.0.0-next.51

package/src/store/user/slices/settings/action.ts

@@ -26,6 +26,10 @@ export interface UserSettingsAction {
   setSettings: (settings: PartialDeep<UserSettings>) => Promise<void>;
   updateDefaultAgent: (agent: PartialDeep<LobeAgentSettings>) => Promise<void>;
   updateGeneralConfig: (settings: Partial<UserGeneralConfig>) => Promise<void>;
+  updateHumanIntervention: (config: {
+    allowList?: string[];
+    approvalMode?: 'auto-run' | 'allow-list' | 'manual';
+  }) => Promise<void>;
   updateKeyVaults: (settings: Partial<UserKeyVaults>) => Promise<void>;
 
   updateSystemAgent: (
@@ -111,6 +115,14 @@ export const createSettingsSlice: StateCreator<
   updateGeneralConfig: async (general) => {
     await get().setSettings({ general });
   },
+  updateHumanIntervention: async (config) => {
+    const current = get().settings.tool?.humanIntervention || {};
+    await get().setSettings({
+      tool: {
+        humanIntervention: { ...current, ...config },
+      },
+    });
+  },
   updateKeyVaults: async (keyVaults) => {
     await get().setSettings({ keyVaults });
   },

package/src/store/user/slices/settings/selectors/__snapshots__/settings.test.ts.snap

@@ -95,13 +95,6 @@ exports[`settingsSelectors > currentTTS > should merge DEFAULT_TTS_CONFIG and s.
 }
 `;
 
-exports[`settingsSelectors > dalleConfig > should return the dalle configuration 1`] = `
-{
-  "apiKey": "dalle-api-key",
-  "autoGenerate": true,
-}
-`;
-
 exports[`settingsSelectors > defaultAgent > should merge DEFAULT_AGENT and s.settings.defaultAgent correctly 1`] = `
 {
   "config": {

package/src/store/user/slices/settings/selectors/index.ts

@@ -2,3 +2,4 @@ export { userGeneralSettingsSelectors } from './general';
 export { keyVaultsConfigSelectors } from './keyVaults';
 export { settingsSelectors } from './settings';
 export { systemAgentSelectors } from './systemAgent';
+export { toolInterventionSelectors } from './toolIntervention';

package/src/store/user/slices/settings/selectors/settings.test.ts

@@ -120,43 +120,6 @@ describe('settingsSelectors', () => {
     });
   });
 
-  describe('dalleConfig', () => {
-    it('should return the dalle configuration', () => {
-      const s = {
-        settings: {
-          tool: {
-            dalle: {
-              apiKey: 'dalle-api-key',
-              autoGenerate: true,
-            },
-          },
-        },
-      } as unknown as UserStore;
-
-      const result = settingsSelectors.dalleConfig(s);
-
-      expect(result).toMatchSnapshot();
-    });
-  });
-
-  describe('isDalleAutoGenerating', () => {
-    it('should return the autoGenerate flag from dalle configuration', () => {
-      const s = {
-        settings: {
-          tool: {
-            dalle: {
-              autoGenerate: true,
-            },
-          },
-        },
-      } as unknown as UserStore;
-
-      const result = settingsSelectors.isDalleAutoGenerating(s);
-
-      expect(result).toBe(true);
-    });
-  });
-
   describe('getProviderConfigById', () => {
     it('should return the provider config for a given provider id', () => {
       const providerConfig = {

package/src/store/user/slices/settings/selectors/settings.ts

@@ -36,9 +36,6 @@ const defaultAgentMeta = (s: UserStore) => merge(DEFAULT_AGENT_META, defaultAgen
 
 const exportSettings = currentSettings;
 
-const dalleConfig = (s: UserStore) => currentSettings(s).tool?.dalle || {};
-const isDalleAutoGenerating = (s: UserStore) => currentSettings(s).tool?.dalle?.autoGenerate;
-
 const currentSystemAgent = (s: UserStore) =>
   merge(DEFAULT_SYSTEM_AGENT_CONFIG, currentSettings(s).systemAgent);
 
@@ -50,12 +47,10 @@ export const settingsSelectors = {
   currentSettings,
   currentSystemAgent,
   currentTTS,
-  dalleConfig,
   defaultAgent,
   defaultAgentConfig,
   defaultAgentMeta,
   exportSettings,
   getHotkeyById,
-  isDalleAutoGenerating,
   providerConfig: getProviderConfigById,
 };

package/src/store/user/slices/settings/selectors/toolIntervention.ts

@@ -0,0 +1,17 @@
+import type { UserStore } from '@/store/user';
+
+import { currentSettings } from './settings';
+
+const humanInterventionConfig = (s: UserStore) => currentSettings(s).tool?.humanIntervention || {};
+
+const interventionApprovalMode = (s: UserStore) =>
+  currentSettings(s).tool?.humanIntervention?.approvalMode || 'manual';
+
+const interventionAllowList = (s: UserStore) =>
+  currentSettings(s).tool?.humanIntervention?.allowList || [];
+
+export const toolInterventionSelectors = {
+  allowList: interventionAllowList,
+  approvalMode: interventionApprovalMode,
+  config: humanInterventionConfig,
+};

package/src/tools/interventions.ts

@@ -0,0 +1,8 @@
+import { BuiltinIntervention } from '@lobechat/types';
+
+import { LocalSystemManifest } from './local-system';
+import LocalSystem from './local-system/Intervention';
+
+export const BuiltinToolInterventions: Record<string, BuiltinIntervention> = {
+  [LocalSystemManifest.identifier]: LocalSystem as BuiltinIntervention,
+};

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

@@ -0,0 +1,56 @@
+import { RunCommandParams } from '@lobechat/electron-client-ipc';
+import { Highlighter, Text } from '@lobehub/ui';
+import { memo } from 'react';
+import { Flexbox } from 'react-layout-kit';
+
+const formatTimeout = (ms?: number) => {
+  if (!ms) return null;
+
+  const seconds = ms / 1000;
+
+  // >= 60s 显示分钟
+  if (seconds >= 60) {
+    const minutes = seconds / 60;
+    return `${minutes.toFixed(1)}min`;
+  }
+
+  // >= 1s 显示秒
+  if (seconds >= 1) {
+    return `${seconds.toFixed(1)}s`;
+  }
+
+  // < 1s 显示毫秒
+  return `${ms}ms`;
+};
+
+interface RunCommandProps extends RunCommandParams {
+  messageId: string;
+}
+
+const RunCommand = memo<RunCommandProps>(({ description, command, timeout }) => {
+  return (
+    <Flexbox gap={8}>
+      <Flexbox horizontal justify={'space-between'}>
+        {description && <Text>{description}</Text>}
+        {timeout && (
+          <Text style={{ fontSize: 12 }} type={'secondary'}>
+            timeout: {formatTimeout(timeout)}
+          </Text>
+        )}
+      </Flexbox>
+      {command && (
+        <Highlighter
+          language={'sh'}
+          showLanguage={false}
+          style={{ padding: '4px 8px' }}
+          variant={'outlined'}
+          wrap
+        >
+          {command}
+        </Highlighter>
+      )}
+    </Flexbox>
+  );
+});
+
+export default RunCommand;

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

@@ -0,0 +1,17 @@
+import { RunCommandParams } from '@lobechat/electron-client-ipc';
+import { BuiltinInterventionProps } from '@lobechat/types';
+import { memo } from 'react';
+
+import RunCommand from './RunCommand';
+
+const Intervention = memo<BuiltinInterventionProps<RunCommandParams>>(
+  ({ apiName, args, messageId }) => {
+    if (apiName === 'runCommand') {
+      return <RunCommand {...args} messageId={messageId} />;
+    }
+
+    return null;
+  },
+);
+
+export default Intervention;

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

@@ -1,35 +1,114 @@
-import { RunCommandParams } from '@lobechat/electron-client-ipc';
+import { CheckCircleFilled, CloseCircleFilled } from '@ant-design/icons';
+import { RunCommandParams, RunCommandResult } from '@lobechat/electron-client-ipc';
 import { ChatMessagePluginError } from '@lobechat/types';
-import { Terminal } from '@xterm/xterm';
-import '@xterm/xterm/css/xterm.css';
-import { memo, useEffect, useRef } from 'react';
+import { ActionIcon, Block, Highlighter, Text } from '@lobehub/ui';
+import { createStyles } from 'antd-style';
+import { ChevronDown, ChevronUp } from 'lucide-react';
+import { memo, useState } from 'react';
+import { Flexbox } from 'react-layout-kit';
 
-import { LocalReadFileState } from '@/tools/local-system/type';
+const useStyles = createStyles(({ css, token }) => ({
+  container: css`
+    overflow: hidden;
+    padding-inline: 8px 0;
+  `,
+  head: css`
+    font-family: ${token.fontFamilyCode};
+    font-size: 12px;
+  `,
+  header: css`
+    .action-icon {
+      opacity: 0;
+      transition: opacity 0.2s ease;
+    }
+
+    &:hover {
+      .action-icon {
+        opacity: 1;
+      }
+    }
+  `,
+  statusIcon: css`
+    font-size: 12px;
+  `,
+}));
 
 interface RunCommandProps {
   args: RunCommandParams;
   messageId: string;
   pluginError: ChatMessagePluginError;
-  pluginState: LocalReadFileState;
+  pluginState: {
+    message: string;
+    result: RunCommandResult;
+  };
 }
 
-const RunCommand = memo<RunCommandProps>(({ args }) => {
-  const terminalRef = useRef(null);
-
-  useEffect(() => {
-    if (!terminalRef.current) return;
-
-    const term = new Terminal({ cols: 80, cursorBlink: true, rows: 30 });
-
-    term.open(terminalRef.current);
-    term.write(args.command);
+const RunCommand = memo<RunCommandProps>(({ args, pluginState }) => {
+  const { styles, theme } = useStyles();
+  const { result, message } = pluginState || {};
+  const isSuccess = result?.success;
+  const [expanded, setExpanded] = useState(false);
 
-    return () => {
-      term.dispose();
-    };
-  }, []);
+  return (
+    <Flexbox className={styles.container} gap={8}>
+      {/* Header: Description + Status */}
+      <Flexbox align={'center'} className={styles.header} horizontal justify={'space-between'}>
+        <Flexbox gap={8} horizontal>
+          <Flexbox gap={4} horizontal>
+            {!result ? null : isSuccess ? (
+              <CheckCircleFilled
+                className={styles.statusIcon}
+                style={{ color: theme.colorSuccess }}
+              />
+            ) : (
+              <CloseCircleFilled
+                className={styles.statusIcon}
+                style={{ color: theme.colorError }}
+              />
+            )}
+            {args.description && <Text className={styles.head}>{args.description}</Text>}
+          </Flexbox>
+          {message && (
+            <Flexbox align={'center'} gap={4} horizontal>
+              <Text className={styles.head} type={'secondary'}>
+                {message}
+              </Text>
+            </Flexbox>
+          )}
+        </Flexbox>
+        <Flexbox align={'center'} gap={8} horizontal>
+          <ActionIcon
+            className={`action-icon`}
+            icon={expanded ? ChevronUp : ChevronDown}
+            onClick={() => setExpanded(!expanded)}
+            size={'small'}
+            style={{ opacity: expanded ? 1 : undefined }}
+            title={expanded ? 'Collapse' : 'Expand'}
+          />
+        </Flexbox>
+      </Flexbox>
 
-  return <div ref={terminalRef} />;
+      {/* Command & Output */}
+      {expanded && (
+        <Block gap={8} padding={8} variant={'outlined'}>
+          <Highlighter
+            language={'sh'}
+            showLanguage={false}
+            style={{ paddingInline: 8 }}
+            variant={'borderless'}
+            wrap
+          >
+            {args.command}
+          </Highlighter>
+          {result?.output && (
+            <Highlighter language={'text'} showLanguage={false} variant={'filled'} wrap>
+              {result.output}
+            </Highlighter>
+          )}
+        </Block>
+      )}
+    </Flexbox>
+  );
 });
 
 export default RunCommand;

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

@@ -7,6 +7,7 @@ import { LocalSystemApiName } from '@/tools/local-system';
 import ListFiles from './ListFiles';
 import ReadLocalFile from './ReadLocalFile';
 import RenameLocalFile from './RenameLocalFile';
+import RunCommand from './RunCommand';
 import SearchFiles from './SearchFiles';
 import WriteFile from './WriteFile';
 
@@ -16,6 +17,7 @@ const RenderMap = {
   [LocalSystemApiName.readLocalFile]: ReadLocalFile,
   [LocalSystemApiName.renameLocalFile]: RenameLocalFile,
   [LocalSystemApiName.writeLocalFile]: WriteFile,
+  [LocalSystemApiName.runCommand]: RunCommand,
 };
 
 const LocalFilesRender = memo<BuiltinRenderProps<LocalFileItem[]>>(

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

@@ -3,10 +3,16 @@ import { BuiltinToolManifest } from '@lobechat/types';
 import { systemPrompt } from './systemRole';
 
 export const LocalSystemApiName = {
+  editLocalFile: 'editLocalFile',
+  getCommandOutput: 'getCommandOutput',
+  globLocalFiles: 'globLocalFiles',
+  grepContent: 'grepContent',
+  killCommand: 'killCommand',
   listLocalFiles: 'listLocalFiles',
   moveLocalFiles: 'moveLocalFiles',
   readLocalFile: 'readLocalFile',
   renameLocalFile: 'renameLocalFile',
+  runCommand: 'runCommand',
   searchLocalFiles: 'searchLocalFiles',
   writeLocalFile: 'writeLocalFile',
 };
@@ -130,6 +136,7 @@ export const LocalSystemManifest: BuiltinToolManifest = {
     {
       description:
         'Moves or renames multiple files/directories. Input is an array of objects, each containing an oldPath and a newPath.',
+      humanIntervention: 'required',
       name: LocalSystemApiName.moveLocalFiles,
       parameters: {
         properties: {
@@ -195,6 +202,179 @@ export const LocalSystemManifest: BuiltinToolManifest = {
         type: 'object',
       },
     },
+    {
+      description:
+        'Execute a shell command and return its output. Supports both synchronous and background execution with timeout control.',
+      humanIntervention: 'required',
+      name: LocalSystemApiName.runCommand,
+      parameters: {
+        properties: {
+          command: {
+            description: 'The shell command to execute',
+            type: 'string',
+          },
+          description: {
+            description:
+              'Clear description of what this command does (5-10 words, in active voice). Use the same language as the user input.',
+            type: 'string',
+          },
+          run_in_background: {
+            description: 'Set to true to run command in background and return shell_id',
+            type: 'boolean',
+          },
+          timeout: {
+            description: 'Timeout in milliseconds (default: 120000ms, max: 600000ms)',
+            type: 'number',
+          },
+        },
+        required: ['command'],
+        type: 'object',
+      },
+    },
+    {
+      description:
+        'Retrieve output from a running or completed background shell command. Returns only new output since the last check.',
+      name: LocalSystemApiName.getCommandOutput,
+      parameters: {
+        properties: {
+          filter: {
+            description:
+              'Optional regex pattern to filter output lines. Only matching lines are returned.',
+            type: 'string',
+          },
+          shell_id: {
+            description: 'The ID of the background shell to retrieve output from',
+            type: 'string',
+          },
+        },
+        required: ['shell_id'],
+        type: 'object',
+      },
+    },
+    {
+      description: 'Kill a running background shell command by its ID.',
+      name: LocalSystemApiName.killCommand,
+      parameters: {
+        properties: {
+          shell_id: {
+            description: 'The ID of the background shell to kill',
+            type: 'string',
+          },
+        },
+        required: ['shell_id'],
+        type: 'object',
+      },
+    },
+    {
+      description:
+        'Search for content within files using regex patterns. Supports various output modes and filtering options.',
+      name: LocalSystemApiName.grepContent,
+      parameters: {
+        properties: {
+          '-A': {
+            description:
+              'Number of lines to show after each match (requires output_mode: "content")',
+            type: 'number',
+          },
+          '-B': {
+            description:
+              'Number of lines to show before each match (requires output_mode: "content")',
+            type: 'number',
+          },
+          '-C': {
+            description:
+              'Number of lines to show before and after each match (requires output_mode: "content")',
+            type: 'number',
+          },
+          '-i': {
+            description: 'Case insensitive search',
+            type: 'boolean',
+          },
+          '-n': {
+            description: 'Show line numbers in output (requires output_mode: "content")',
+            type: 'boolean',
+          },
+          'glob': {
+            description: 'Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")',
+            type: 'string',
+          },
+          'head_limit': {
+            description: 'Limit output to first N results',
+            type: 'number',
+          },
+          'multiline': {
+            description: 'Enable multiline mode where . matches newlines',
+            type: 'boolean',
+          },
+          'output_mode': {
+            description:
+              'Output mode: "content" (matching lines), "files_with_matches" (file paths), "count" (match counts)',
+            enum: ['content', 'files_with_matches', 'count'],
+            type: 'string',
+          },
+          'path': {
+            description: 'File or directory to search in (defaults to current working directory)',
+            type: 'string',
+          },
+          'pattern': {
+            description: 'The regular expression pattern to search for',
+            type: 'string',
+          },
+          'type': {
+            description: 'File type to search (e.g. "js", "py", "rust")',
+            type: 'string',
+          },
+        },
+        required: ['pattern'],
+        type: 'object',
+      },
+    },
+    {
+      description:
+        'Find files matching glob patterns. Supports standard glob syntax like "**/*.js" or "src/**/*.ts".',
+      name: LocalSystemApiName.globLocalFiles,
+      parameters: {
+        properties: {
+          path: {
+            description: 'The directory to search in (defaults to current working directory)',
+            type: 'string',
+          },
+          pattern: {
+            description: 'The glob pattern to match files against (e.g. "**/*.js", "*.{ts,tsx}")',
+            type: 'string',
+          },
+        },
+        required: ['pattern'],
+        type: 'object',
+      },
+    },
+    {
+      description:
+        'Perform exact string replacements in files. Must read the file first before editing.',
+      name: LocalSystemApiName.editLocalFile,
+      parameters: {
+        properties: {
+          file_path: {
+            description: 'The absolute path to the file to modify',
+            type: 'string',
+          },
+          new_string: {
+            description: 'The text to replace with (must differ from old_string)',
+            type: 'string',
+          },
+          old_string: {
+            description: 'The exact text to replace',
+            type: 'string',
+          },
+          replace_all: {
+            description: 'Replace all occurrences of old_string (default: false)',
+            type: 'boolean',
+          },
+        },
+        required: ['file_path', 'old_string', 'new_string'],
+        type: 'object',
+      },
+    },
   ],
   identifier: 'lobe-local-system',
   meta: {

package/src/tools/local-system/systemRole.ts

@@ -15,19 +15,33 @@ Here are some known locations and system details on the user's system. User is u
 <core_capabilities>
 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.
 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.  **writeFile**: Write content to a specific file, only support plain text file like \`.text\` or \`.md\`
-4.  **searchLocalFiles**: Searches for files based on keywords and other criteria. Use this tool to find files if the user is unsure about the exact path.
+3.  **writeLocalFile**: Write content to a specific file, only support plain text file like \`.text\` or \`.md\`
+4.  **searchLocalFiles**: Searches for files based on keywords and other criteria using Spotlight (macOS) or native search. Use this tool to find files if the user is unsure about the exact path.
 5.  **renameLocalFile**: Renames a single file or directory in its current location.
 6.  **moveLocalFiles**: Moves multiple files or directories. Can be used for renaming during the move.
+7.  **editLocalFile**: Performs exact string replacements in files. Must read the file first before editing.
+
+**Shell Commands:**
+8.  **runCommand**: Execute shell commands with timeout control. Supports both synchronous and background execution. When providing a description, always use the same language as the user's input.
+9.  **getCommandOutput**: Retrieve output from running background commands. Returns only new output since last check.
+10. **killCommand**: Terminate a running background shell command by its ID.
+
+**Search & Find:**
+11. **grepContent**: Search for content within files using regex patterns. Supports various output modes, filtering, and context lines.
+12. **globLocalFiles**: Find files matching glob patterns (e.g., "**/*.js", "*.{ts,tsx}").
 </core_capabilities>
 
 <workflow>
-1. Understand the user's request regarding local files (listing, reading, searching, renaming, moving, writing).
-2. Select the appropriate tool (listFiles, readFile, searchFiles, renameFile, moveLocalFiles, writeFile).
-3. Execute the file operation. **If the user mentions a common location (like Desktop, Documents, Downloads, etc.) without providing a full path, use the corresponding path from the <user_context> section.**
-4. Present the results (directory listing, file content, search results) or confirmation of the rename or move operation.
+1. Understand the user's request regarding local operations (files, commands, searches).
+2. Select the appropriate tool:
+   - File operations: listLocalFiles, readLocalFile, writeLocalFile, editLocalFile, searchLocalFiles, renameLocalFile, moveLocalFiles
+   - Shell commands: runCommand, getCommandOutput, killCommand
+   - Search/Find: grepContent, globLocalFiles
+3. Execute the operation. **If the user mentions a common location (like Desktop, Documents, Downloads, etc.) without providing a full path, use the corresponding path from the <user_context> section.**
+4. Present the results or confirmation.
 </workflow>
 
 <tool_usage_guidelines>
@@ -54,7 +68,37 @@ You have access to a set of tools to interact with the user's local file system:
       - 'oldPath': The current absolute path of the file/directory to move or rename.
       - 'newPath': The target absolute path for the file/directory (can include a new name).
     Example: items: [{ oldPath: "/path/to/file1.txt", newPath: "/new/path/to/fileA.txt" }, { oldPath: "/path/to/folderB", newPath: "/archive/folderB_renamed" }]
-- For writing to a file: Use 'writeFile' with the file path and the content to be written. Be cautious as this might overwrite existing files.
+- For writing to a file: Use 'writeLocalFile' with the file path and the content to be written. Be cautious as this might overwrite existing files.
+- For editing a file: Use 'editLocalFile'. Provide the following parameters:
+    - 'file_path': The absolute path to the file to modify.
+    - 'old_string': The exact text to replace.
+    - 'new_string': The text to replace with.
+    - 'replace_all' (Optional): Set to true to replace all occurrences (default: false, replaces only first occurrence).
+    Note: You MUST read the file first using 'readLocalFile' before editing to verify the content.
+- For executing shell commands: Use 'runCommand'. Provide the following parameters:
+    - 'command': The shell command to execute.
+    - 'description' (Optional but recommended): A clear, concise description of what the command does (5-10 words, in active voice). **IMPORTANT: Always use the same language as the user's input.** If the user speaks Chinese, write the description in Chinese; if English, use English, etc.
+    - 'run_in_background' (Optional): Set to true to run in background and get a shell_id for later checking output.
+    - 'timeout' (Optional): Timeout in milliseconds (default: 120000ms, max: 600000ms).
+    The command runs in cmd.exe on Windows or /bin/sh on macOS/Linux.
+- For retrieving output from background commands: Use 'getCommandOutput'. Provide:
+    - 'shell_id': The ID returned from runCommand when run_in_background was true.
+    - 'filter' (Optional): A regex pattern to filter output lines.
+    Returns only new output since the last check.
+- For killing background commands: Use 'killCommand' with 'shell_id'.
+- For searching content in files: Use 'grepContent'. Provide:
+    - 'pattern': The regex pattern to search for.
+    - 'path' (Optional): File or directory to search (defaults to current working directory).
+    - 'output_mode' (Optional): "content" (matching lines), "files_with_matches" (file paths, default), "count" (match counts).
+    - 'glob' (Optional): Glob pattern to filter files (e.g., "*.js", "*.{ts,tsx}").
+    - '-i' (Optional): Case insensitive search.
+    - '-n' (Optional): Show line numbers (requires output_mode: "content").
+    - '-A/-B/-C' (Optional): Show N lines after/before/around matches (requires output_mode: "content").
+    - 'head_limit' (Optional): Limit results to first N matches.
+- For finding files by pattern: Use 'globLocalFiles'. Provide:
+    - 'pattern': Glob pattern (e.g., "**/*.js", "src/**/*.ts").
+    - 'path' (Optional): Directory to search in (defaults to current working directory).
+    Returns files sorted by modification time (most recent first).
 </tool_usage_guidelines>
 
 <security_considerations>
@@ -62,6 +106,16 @@ You have access to a set of tools to interact with the user's local file system:
 - Confirm with the user before moving files to significantly different locations or when renaming might cause confusion or potential data loss if the target exists (though the tool should handle this).
 - Do not attempt to access files outside the user's designated workspace or allowed directories unless explicitly permitted.
 - Handle file paths carefully to avoid unintended access or errors.
+- When running shell commands:
+    - Never execute commands that could harm the system or delete important data without explicit user confirmation.
+    - Be cautious with commands that have side effects (e.g., rm, sudo, format).
+    - Always describe what a command will do before running it, especially for non-trivial operations.
+    - Always provide a clear 'description' parameter in the user's language to help them understand what the command does.
+    - Use appropriate timeouts to prevent commands from running indefinitely.
+- When editing files:
+    - Always read the file first to verify its current content.
+    - Ensure old_string exactly matches the text to be replaced to avoid unintended changes.
+    - Be cautious when using replace_all option.
 </security_considerations>
 
 <response_format>