@lobehub/lobehub 2.0.0-next.375 → 2.0.0-next.376

package/.github/workflows/claude-migration-support.yml

@@ -1,5 +1,4 @@
 name: Claude Migration Support
-description: Automatically respond to migration feedback issues using Claude Code
 
 on:
   issue_comment:
@@ -76,6 +75,7 @@ jobs:
 
             3. Read additional reference files:
             - Main auth documentation: `cat docs/self-hosting/advanced/auth.mdx`
+            - Migration internals: `cat docs/self-hosting/advanced/auth/migration-internals.mdx`
             - Deprecated env vars checker: `cat scripts/_shared/checkDeprecatedAuth.js`
 
             4. Analyze the user's comment and determine:

package/.github/workflows/revalidate-docs.yml

@@ -0,0 +1,25 @@
+name: Revalidate Docs
+permissions:
+  contents: read
+
+on:
+  push:
+    branches:
+      - main
+      - next
+    paths:
+      - 'docs/**'
+
+jobs:
+  revalidate:
+    name: Revalidate Docs
+    runs-on: ubuntu-latest
+    steps:
+      - name: Trigger docs revalidation
+        run: |
+          response=$(curl "${{ secrets.DOCS_REVALIDATE_URL }}" --silent --show-error)
+          echo "Response: $response"
+          if [ "$response" != '{"success":true}' ]; then
+            echo "Error: Unexpected response"
+            exit 1
+          fi

package/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 # Changelog
 
+## [Version 2.0.0-next.376](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.375...v2.0.0-next.376)
+
+<sup>Released on **2026-01-25**</sup>
+
+#### ♻ Code Refactoring
+
+- **misc**: Refactor search model implement.
+
+#### ✨ Features
+
+- **trpc**: Add response metadata and auth header handling.
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix add message and improve local system tool.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Code refactoring
+
+- **misc**: Refactor search model implement, closes [#11825](https://github.com/lobehub/lobe-chat/issues/11825) ([3cf0bfa](https://github.com/lobehub/lobe-chat/commit/3cf0bfa))
+
+#### What's improved
+
+- **trpc**: Add response metadata and auth header handling, closes [#11816](https://github.com/lobehub/lobe-chat/issues/11816) ([1276a87](https://github.com/lobehub/lobe-chat/commit/1276a87))
+
+#### What's fixed
+
+- **misc**: Fix add message and improve local system tool, closes [#11815](https://github.com/lobehub/lobe-chat/issues/11815) ([3b41009](https://github.com/lobehub/lobe-chat/commit/3b41009))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.375](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.374...v2.0.0-next.375)
 
 <sup>Released on **2026-01-25**</sup>

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

@@ -548,7 +548,13 @@ export default class LocalFileCtr extends ControllerModule {
         filesToSearch = [searchPath];
       } else {
         // Use glob pattern if provided, otherwise search all files
-        const globPattern = params.glob || '**/*';
+        // If glob doesn't contain directory separator and doesn't start with **,
+        // auto-prefix with **/ to make it recursive
+        let globPattern = params.glob || '**/*';
+        if (params.glob && !params.glob.includes('/') && !params.glob.startsWith('**')) {
+          globPattern = `**/${params.glob}`;
+        }
+
         filesToSearch = await fg(globPattern, {
           absolute: true,
           cwd: searchPath,

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

@@ -15,6 +15,19 @@ import { ControllerModule, IpcMethod } from './index';
 
 const logger = createLogger('controllers:ShellCommandCtr');
 
+// Maximum output length to prevent context explosion
+const MAX_OUTPUT_LENGTH = 10_000;
+
+/**
+ * Truncate string to max length with ellipsis indicator
+ */
+const truncateOutput = (str: string, maxLength: number = MAX_OUTPUT_LENGTH): string => {
+  if (str.length <= maxLength) return str;
+  return (
+    str.slice(0, maxLength) + '\n... [truncated, ' + (str.length - maxLength) + ' more characters]'
+  );
+};
+
 interface ShellProcess {
   lastReadStderr: number;
   lastReadStdout: number;
@@ -104,8 +117,8 @@ export default class ShellCommandCtr extends ControllerModule {
             childProcess.kill();
             resolve({
               error: `Command timed out after ${effectiveTimeout}ms`,
-              stderr,
-              stdout,
+              stderr: truncateOutput(stderr),
+              stdout: truncateOutput(stdout),
               success: false,
             });
           }, effectiveTimeout);
@@ -125,9 +138,9 @@ export default class ShellCommandCtr extends ControllerModule {
               logger.info(`${logPrefix} Command completed`, { code, success });
               resolve({
                 exit_code: code || 0,
-                output: stdout + stderr,
-                stderr,
-                stdout,
+                output: truncateOutput(stdout + stderr),
+                stderr: truncateOutput(stderr),
+                stdout: truncateOutput(stdout),
                 success,
               });
             }
@@ -138,8 +151,8 @@ export default class ShellCommandCtr extends ControllerModule {
             logger.error(`${logPrefix} Command failed:`, error);
             resolve({
               error: error.message,
-              stderr,
-              stdout,
+              stderr: truncateOutput(stderr),
+              stdout: truncateOutput(stdout),
               success: false,
             });
           });
@@ -205,10 +218,10 @@ export default class ShellCommandCtr extends ControllerModule {
     });
 
     return {
-      output,
+      output: truncateOutput(output),
       running,
-      stderr: newStderr,
-      stdout: newStdout,
+      stderr: truncateOutput(newStderr),
+      stdout: truncateOutput(newStdout),
       success: true,
     };
   }

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

@@ -552,4 +552,265 @@ describe('LocalFileCtr', () => {
       expect(result.diffText).toContain('+modified line 2');
     });
   });
+
+  describe('handleGrepContent', () => {
+    it('should search content in a single file', async () => {
+      vi.mocked(mockFsPromises.stat).mockResolvedValue({
+        isFile: () => true,
+        isDirectory: () => false,
+      } as any);
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue('Hello world\nTest line\nAnother test');
+
+      const result = await localFileCtr.handleGrepContent({
+        'pattern': 'test',
+        'path': '/test/file.txt',
+        '-i': true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.matches).toContain('/test/file.txt');
+      expect(result.total_matches).toBe(1);
+    });
+
+    it('should search content in directory with default glob pattern', async () => {
+      vi.mocked(mockFsPromises.stat).mockImplementation(async (filePath) => {
+        if (filePath === '/test') {
+          return { isFile: () => false, isDirectory: () => true } as any;
+        }
+        return { isFile: () => true, isDirectory: () => false } as any;
+      });
+      vi.mocked(mockFg).mockResolvedValue(['/test/file1.txt', '/test/file2.txt']);
+      vi.mocked(mockFsPromises.readFile).mockImplementation(async (filePath) => {
+        if (filePath === '/test/file1.txt') return 'Hello world';
+        if (filePath === '/test/file2.txt') return 'Test content';
+        return '';
+      });
+
+      const result = await localFileCtr.handleGrepContent({
+        pattern: 'Hello',
+        path: '/test',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.matches).toContain('/test/file1.txt');
+      expect(result.total_matches).toBe(1);
+      expect(mockFg).toHaveBeenCalledWith('**/*', expect.objectContaining({ cwd: '/test' }));
+    });
+
+    it('should auto-prefix glob pattern with **/ for non-recursive patterns', async () => {
+      vi.mocked(mockFsPromises.stat).mockImplementation(async (filePath) => {
+        if (filePath === '/test') {
+          return { isFile: () => false, isDirectory: () => true } as any;
+        }
+        return { isFile: () => true, isDirectory: () => false } as any;
+      });
+      vi.mocked(mockFg).mockResolvedValue(['/test/src/file1.ts', '/test/lib/file2.tsx']);
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue('const test = "hello";');
+
+      const result = await localFileCtr.handleGrepContent({
+        pattern: 'test',
+        path: '/test',
+        glob: '*.{ts,tsx}',
+      });
+
+      expect(result.success).toBe(true);
+      // Should auto-prefix *.{ts,tsx} with **/ to make it recursive
+      expect(mockFg).toHaveBeenCalledWith(
+        '**/*.{ts,tsx}',
+        expect.objectContaining({ cwd: '/test' }),
+      );
+    });
+
+    it('should not modify glob pattern that already contains path separator', async () => {
+      vi.mocked(mockFsPromises.stat).mockImplementation(async (filePath) => {
+        if (filePath === '/test') {
+          return { isFile: () => false, isDirectory: () => true } as any;
+        }
+        return { isFile: () => true, isDirectory: () => false } as any;
+      });
+      vi.mocked(mockFg).mockResolvedValue(['/test/src/file1.ts']);
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue('const test = "hello";');
+
+      const result = await localFileCtr.handleGrepContent({
+        pattern: 'test',
+        path: '/test',
+        glob: 'src/*.ts',
+      });
+
+      expect(result.success).toBe(true);
+      // Should not modify glob pattern that already contains /
+      expect(mockFg).toHaveBeenCalledWith('src/*.ts', expect.objectContaining({ cwd: '/test' }));
+    });
+
+    it('should not modify glob pattern that starts with **', async () => {
+      vi.mocked(mockFsPromises.stat).mockImplementation(async (filePath) => {
+        if (filePath === '/test') {
+          return { isFile: () => false, isDirectory: () => true } as any;
+        }
+        return { isFile: () => true, isDirectory: () => false } as any;
+      });
+      vi.mocked(mockFg).mockResolvedValue(['/test/src/file1.ts']);
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue('const test = "hello";');
+
+      const result = await localFileCtr.handleGrepContent({
+        pattern: 'test',
+        path: '/test',
+        glob: '**/components/*.tsx',
+      });
+
+      expect(result.success).toBe(true);
+      // Should not modify glob pattern that already starts with **
+      expect(mockFg).toHaveBeenCalledWith(
+        '**/components/*.tsx',
+        expect.objectContaining({ cwd: '/test' }),
+      );
+    });
+
+    it('should filter by type when provided', async () => {
+      vi.mocked(mockFsPromises.stat).mockImplementation(async (filePath) => {
+        if (filePath === '/test') {
+          return { isFile: () => false, isDirectory: () => true } as any;
+        }
+        return { isFile: () => true, isDirectory: () => false } as any;
+      });
+      // fast-glob returns all files, then type filter is applied
+      vi.mocked(mockFg).mockResolvedValue(['/test/file1.ts', '/test/file2.js', '/test/file3.ts']);
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue('unique_pattern');
+
+      const result = await localFileCtr.handleGrepContent({
+        pattern: 'unique_pattern',
+        path: '/test',
+        type: 'ts',
+      });
+
+      expect(result.success).toBe(true);
+      // Type filter should exclude .js files from being searched
+      // Only .ts files should be in the results
+      expect(result.matches).not.toContain('/test/file2.js');
+      // At least one .ts file should match
+      expect(result.matches.length).toBeGreaterThan(0);
+      expect(result.matches.every((m) => m.endsWith('.ts'))).toBe(true);
+    });
+
+    it('should return content mode with line numbers', async () => {
+      vi.mocked(mockFsPromises.stat).mockImplementation(async (filePath) => {
+        if (filePath === '/test') {
+          return { isFile: () => false, isDirectory: () => true } as any;
+        }
+        return { isFile: () => true, isDirectory: () => false } as any;
+      });
+      vi.mocked(mockFg).mockResolvedValue(['/test/file.txt']);
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue('line 1\ntest line\nline 3');
+
+      const result = await localFileCtr.handleGrepContent({
+        'pattern': 'test',
+        'path': '/test',
+        'output_mode': 'content',
+        '-n': true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.matches.some((m) => m.includes('2:'))).toBe(true);
+    });
+
+    it('should return count mode', async () => {
+      vi.mocked(mockFsPromises.stat).mockImplementation(async (filePath) => {
+        if (filePath === '/test') {
+          return { isFile: () => false, isDirectory: () => true } as any;
+        }
+        return { isFile: () => true, isDirectory: () => false } as any;
+      });
+      vi.mocked(mockFg).mockResolvedValue(['/test/file.txt']);
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue('test one\ntest two\ntest three');
+
+      const result = await localFileCtr.handleGrepContent({
+        pattern: 'test',
+        path: '/test',
+        output_mode: 'count',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.matches).toContain('/test/file.txt:3');
+      expect(result.total_matches).toBe(3);
+    });
+
+    it('should respect head_limit', async () => {
+      vi.mocked(mockFsPromises.stat).mockImplementation(async (filePath) => {
+        if (filePath === '/test') {
+          return { isFile: () => false, isDirectory: () => true } as any;
+        }
+        return { isFile: () => true, isDirectory: () => false } as any;
+      });
+      vi.mocked(mockFg).mockResolvedValue([
+        '/test/file1.txt',
+        '/test/file2.txt',
+        '/test/file3.txt',
+        '/test/file4.txt',
+        '/test/file5.txt',
+      ]);
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue('test content');
+
+      const result = await localFileCtr.handleGrepContent({
+        pattern: 'test',
+        path: '/test',
+        head_limit: 2,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.matches.length).toBe(2);
+    });
+
+    it('should handle case insensitive search', async () => {
+      vi.mocked(mockFsPromises.stat).mockResolvedValue({
+        isFile: () => true,
+        isDirectory: () => false,
+      } as any);
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue('Hello World\nHELLO world\nhello WORLD');
+
+      const result = await localFileCtr.handleGrepContent({
+        'pattern': 'hello',
+        'path': '/test/file.txt',
+        '-i': true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.matches).toContain('/test/file.txt');
+    });
+
+    it('should handle grep error gracefully', async () => {
+      vi.mocked(mockFsPromises.stat).mockRejectedValue(new Error('Path not found'));
+
+      const result = await localFileCtr.handleGrepContent({
+        pattern: 'test',
+        path: '/nonexistent',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.matches).toEqual([]);
+      expect(result.total_matches).toBe(0);
+    });
+
+    it('should skip unreadable files gracefully', async () => {
+      vi.mocked(mockFsPromises.stat).mockImplementation(async (filePath) => {
+        if (filePath === '/test') {
+          return { isFile: () => false, isDirectory: () => true } as any;
+        }
+        return { isFile: () => true, isDirectory: () => false } as any;
+      });
+      vi.mocked(mockFg).mockResolvedValue(['/test/file1.txt', '/test/file2.txt']);
+      vi.mocked(mockFsPromises.readFile).mockImplementation(async (filePath) => {
+        if (filePath === '/test/file1.txt') throw new Error('Permission denied');
+        return 'test content';
+      });
+
+      const result = await localFileCtr.handleGrepContent({
+        pattern: 'test',
+        path: '/test',
+      });
+
+      expect(result.success).toBe(true);
+      // Should still find match in file2.txt despite file1.txt error
+      expect(result.matches).toContain('/test/file2.txt');
+    });
+  });
 });

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

@@ -193,6 +193,42 @@ describe('ShellCommandCtr', () => {
         expect(result.stderr).toBe('error message\n');
       });
 
+      it('should truncate long output to prevent context explosion', async () => {
+        let exitCallback: (code: number) => void;
+        let stdoutCallback: (data: Buffer) => void;
+
+        mockChildProcess.on.mockImplementation((event: string, callback: any) => {
+          if (event === 'exit') {
+            exitCallback = callback;
+            setTimeout(() => exitCallback(0), 10);
+          }
+          return mockChildProcess;
+        });
+
+        mockChildProcess.stdout.on.mockImplementation((event: string, callback: any) => {
+          if (event === 'data') {
+            stdoutCallback = callback;
+            // Simulate very long output (15k characters)
+            const longOutput = 'x'.repeat(15_000);
+            setTimeout(() => stdoutCallback(Buffer.from(longOutput)), 5);
+          }
+          return mockChildProcess.stdout;
+        });
+
+        mockChildProcess.stderr.on.mockImplementation(() => mockChildProcess.stderr);
+
+        const result = await shellCommandCtr.handleRunCommand({
+          command: 'command-with-long-output',
+          description: 'long output command',
+        });
+
+        expect(result.success).toBe(true);
+        // Output should be truncated to ~10k + truncation message
+        expect(result.stdout!.length).toBeLessThan(15_000);
+        expect(result.stdout).toContain('truncated');
+        expect(result.stdout).toContain('more characters');
+      });
+
       it('should enforce timeout limits', async () => {
         mockChildProcess.on.mockImplementation(() => mockChildProcess);
         mockChildProcess.stdout.on.mockImplementation(() => mockChildProcess.stdout);

package/apps/desktop/src/main/core/infrastructure/BackendProxyProtocolManager.ts

@@ -1,3 +1,4 @@
+import { AUTH_REQUIRED_HEADER } from '@lobechat/desktop-bridge';
 import { BrowserWindow, type Session } from 'electron';
 
 import { isDev } from '@/const/env';
@@ -167,7 +168,7 @@ export class BackendProxyProtocolManager {
         // The server sets X-Auth-Required header for real authentication failures (e.g., token expired)
         // Other 401 errors (e.g., invalid API keys) should not trigger re-authentication
         if (upstreamResponse.status === 401) {
-          const authRequired = upstreamResponse.headers.get('X-Auth-Required') === 'true';
+          const authRequired = upstreamResponse.headers.get(AUTH_REQUIRED_HEADER) === 'true';
           if (authRequired) {
             this.notifyAuthorizationRequired();
           }

package/changelog/v1.json

@@ -1,4 +1,16 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "Refactor search model implement."
+      ],
+      "fixes": [
+        "Fix add message and improve local system tool."
+      ]
+    },
+    "date": "2026-01-25",
+    "version": "2.0.0-next.376"
+  },
   {
     "children": {
       "fixes": [