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

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 # Changelog
 
+## [Version 2.0.0-next.52](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.51...v2.0.0-next.52)
+
+<sup>Released on **2025-11-13**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Filter out reasoning fields from messages in ChatCompletion API.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Filter out reasoning fields from messages in ChatCompletion API, closes [#10203](https://github.com/lobehub/lobe-chat/issues/10203) [#10193](https://github.com/lobehub/lobe-chat/issues/10193) ([5f28b2c](https://github.com/lobehub/lobe-chat/commit/5f28b2c))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+## [Version 2.0.0-next.51](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.50...v2.0.0-next.51)
+
+<sup>Released on **2025-11-13**</sup>
+
+#### 💄 Styles
+
+- **misc**: Update ERNIE-5.0-Thinking-Preview model.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Update ERNIE-5.0-Thinking-Preview model, closes [#10196](https://github.com/lobehub/lobe-chat/issues/10196) ([89f3eed](https://github.com/lobehub/lobe-chat/commit/89f3eed))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.50](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.49...v2.0.0-next.50)
 
 <sup>Released on **2025-11-13**</sup>

package/apps/desktop/src/main/controllers/LocalFileCtr.ts

@@ -467,15 +467,35 @@ export default class LocalFileCtr extends ControllerModule {
    */
   @ipcClientEvent('searchLocalFiles')
   async handleLocalFilesSearch(params: LocalSearchFilesParams): Promise<FileResult[]> {
-    logger.debug('Received file search request:', { keywords: params.keywords });
+    logger.debug('Received file search request:', {
+      directory: params.directory,
+      keywords: params.keywords,
+    });
 
-    const options: Omit<SearchOptions, 'keywords'> = {
-      limit: 30,
+    // Build search options from params, mapping directory to onlyIn
+    const options: SearchOptions = {
+      contentContains: params.contentContains,
+      createdAfter: params.createdAfter ? new Date(params.createdAfter) : undefined,
+      createdBefore: params.createdBefore ? new Date(params.createdBefore) : undefined,
+      detailed: params.detailed,
+      exclude: params.exclude,
+      fileTypes: params.fileTypes,
+      keywords: params.keywords,
+      limit: params.limit || 30,
+      liveUpdate: params.liveUpdate,
+      modifiedAfter: params.modifiedAfter ? new Date(params.modifiedAfter) : undefined,
+      modifiedBefore: params.modifiedBefore ? new Date(params.modifiedBefore) : undefined,
+      onlyIn: params.directory, // Map directory param to onlyIn option
+      sortBy: params.sortBy,
+      sortDirection: params.sortDirection,
     };
 
     try {
-      const results = await this.searchService.search(params.keywords, options);
-      logger.debug('File search completed', { count: results.length });
+      const results = await this.searchService.search(options.keywords, options);
+      logger.debug('File search completed', {
+        count: results.length,
+        directory: params.directory,
+      });
       return results;
     } catch (error) {
       logger.error('File search failed:', error);

package/apps/desktop/src/main/controllers/ShellCommandCtr.ts

@@ -0,0 +1,242 @@
+import {
+  GetCommandOutputParams,
+  GetCommandOutputResult,
+  KillCommandParams,
+  KillCommandResult,
+  RunCommandParams,
+  RunCommandResult,
+} from '@lobechat/electron-client-ipc';
+import { ChildProcess, spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+
+import { createLogger } from '@/utils/logger';
+
+import { ControllerModule, ipcClientEvent } from './index';
+
+const logger = createLogger('controllers:ShellCommandCtr');
+
+interface ShellProcess {
+  lastReadStderr: number;
+  lastReadStdout: number;
+  process: ChildProcess;
+  stderr: string[];
+  stdout: string[];
+}
+
+export default class ShellCommandCtr extends ControllerModule {
+  // Shell process management
+  private shellProcesses = new Map<string, ShellProcess>();
+
+  @ipcClientEvent('runCommand')
+  async handleRunCommand({
+    command,
+    description,
+    run_in_background,
+    timeout = 120_000,
+  }: RunCommandParams): Promise<RunCommandResult> {
+    const logPrefix = `[runCommand: ${description || command.slice(0, 50)}]`;
+    logger.debug(`${logPrefix} Starting command execution`, {
+      background: run_in_background,
+      timeout,
+    });
+
+    // Validate timeout
+    const effectiveTimeout = Math.min(Math.max(timeout, 1000), 600_000);
+
+    // Cross-platform shell selection
+    const shellConfig =
+      process.platform === 'win32'
+        ? { args: ['/c', command], cmd: 'cmd.exe' }
+        : { args: ['-c', command], cmd: '/bin/sh' };
+
+    try {
+      if (run_in_background) {
+        // Background execution
+        const shellId = randomUUID();
+        const childProcess = spawn(shellConfig.cmd, shellConfig.args, {
+          env: process.env,
+          shell: false,
+        });
+
+        const shellProcess: ShellProcess = {
+          lastReadStderr: 0,
+          lastReadStdout: 0,
+          process: childProcess,
+          stderr: [],
+          stdout: [],
+        };
+
+        // Capture output
+        childProcess.stdout?.on('data', (data) => {
+          shellProcess.stdout.push(data.toString());
+        });
+
+        childProcess.stderr?.on('data', (data) => {
+          shellProcess.stderr.push(data.toString());
+        });
+
+        childProcess.on('exit', (code) => {
+          logger.debug(`${logPrefix} Background process exited`, { code, shellId });
+        });
+
+        this.shellProcesses.set(shellId, shellProcess);
+
+        logger.info(`${logPrefix} Started background execution`, { shellId });
+        return {
+          shell_id: shellId,
+          success: true,
+        };
+      } else {
+        // Synchronous execution with timeout
+        return new Promise((resolve) => {
+          const childProcess = spawn(shellConfig.cmd, shellConfig.args, {
+            env: process.env,
+            shell: false,
+          });
+
+          let stdout = '';
+          let stderr = '';
+          let killed = false;
+
+          const timeoutHandle = setTimeout(() => {
+            killed = true;
+            childProcess.kill();
+            resolve({
+              error: `Command timed out after ${effectiveTimeout}ms`,
+              stderr,
+              stdout,
+              success: false,
+            });
+          }, effectiveTimeout);
+
+          childProcess.stdout?.on('data', (data) => {
+            stdout += data.toString();
+          });
+
+          childProcess.stderr?.on('data', (data) => {
+            stderr += data.toString();
+          });
+
+          childProcess.on('exit', (code) => {
+            if (!killed) {
+              clearTimeout(timeoutHandle);
+              const success = code === 0;
+              logger.info(`${logPrefix} Command completed`, { code, success });
+              resolve({
+                exit_code: code || 0,
+                output: stdout + stderr,
+                stderr,
+                stdout,
+                success,
+              });
+            }
+          });
+
+          childProcess.on('error', (error) => {
+            clearTimeout(timeoutHandle);
+            logger.error(`${logPrefix} Command failed:`, error);
+            resolve({
+              error: error.message,
+              stderr,
+              stdout,
+              success: false,
+            });
+          });
+        });
+      }
+    } catch (error) {
+      logger.error(`${logPrefix} Failed to execute command:`, error);
+      return {
+        error: (error as Error).message,
+        success: false,
+      };
+    }
+  }
+
+  @ipcClientEvent('getCommandOutput')
+  async handleGetCommandOutput({
+    filter,
+    shell_id,
+  }: GetCommandOutputParams): Promise<GetCommandOutputResult> {
+    const logPrefix = `[getCommandOutput: ${shell_id}]`;
+    logger.debug(`${logPrefix} Retrieving output`);
+
+    const shellProcess = this.shellProcesses.get(shell_id);
+    if (!shellProcess) {
+      logger.error(`${logPrefix} Shell process not found`);
+      return {
+        error: `Shell ID ${shell_id} not found`,
+        output: '',
+        running: false,
+        stderr: '',
+        stdout: '',
+        success: false,
+      };
+    }
+
+    const { lastReadStderr, lastReadStdout, process: childProcess, stderr, stdout } = shellProcess;
+
+    // Get new output since last read
+    const newStdout = stdout.slice(lastReadStdout).join('');
+    const newStderr = stderr.slice(lastReadStderr).join('');
+    let output = newStdout + newStderr;
+
+    // Apply filter if provided
+    if (filter) {
+      try {
+        const regex = new RegExp(filter, 'gm');
+        const lines = output.split('\n');
+        output = lines.filter((line) => regex.test(line)).join('\n');
+      } catch (error) {
+        logger.error(`${logPrefix} Invalid filter regex:`, error);
+      }
+    }
+
+    // Update last read positions separately
+    shellProcess.lastReadStdout = stdout.length;
+    shellProcess.lastReadStderr = stderr.length;
+
+    const running = childProcess.exitCode === null;
+
+    logger.debug(`${logPrefix} Output retrieved`, {
+      outputLength: output.length,
+      running,
+    });
+
+    return {
+      output,
+      running,
+      stderr: newStderr,
+      stdout: newStdout,
+      success: true,
+    };
+  }
+
+  @ipcClientEvent('killCommand')
+  async handleKillCommand({ shell_id }: KillCommandParams): Promise<KillCommandResult> {
+    const logPrefix = `[killCommand: ${shell_id}]`;
+    logger.debug(`${logPrefix} Attempting to kill shell`);
+
+    const shellProcess = this.shellProcesses.get(shell_id);
+    if (!shellProcess) {
+      logger.error(`${logPrefix} Shell process not found`);
+      return {
+        error: `Shell ID ${shell_id} not found`,
+        success: false,
+      };
+    }
+
+    try {
+      shellProcess.process.kill();
+      this.shellProcesses.delete(shell_id);
+      logger.info(`${logPrefix} Shell killed successfully`);
+      return { success: true };
+    } catch (error) {
+      logger.error(`${logPrefix} Failed to kill shell:`, error);
+      return {
+        error: (error as Error).message,
+        success: false,
+      };
+    }
+  }
+}

package/apps/desktop/src/main/controllers/__tests__/LocalFileCtr.test.ts

@@ -345,7 +345,10 @@ describe('LocalFileCtr', () => {
       const result = await localFileCtr.handleLocalFilesSearch({ keywords: 'test' });
 
       expect(result).toEqual(mockResults);
-      expect(mockSearchService.search).toHaveBeenCalledWith('test', { limit: 30 });
+      expect(mockSearchService.search).toHaveBeenCalledWith('test', {
+        keywords: 'test',
+        limit: 30,
+      });
     });
 
     it('should return empty array on search error', async () => {