@lobehub/lobehub 2.0.0-next.22 → 2.0.0-next.23

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 2.0.0-next.23](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.22...v2.0.0-next.23)
+
+<sup>Released on **2025-11-04**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix send message.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix send message, closes [#10041](https://github.com/lobehub/lobe-chat/issues/10041) [#9984](https://github.com/lobehub/lobe-chat/issues/9984) ([7cca60f](https://github.com/lobehub/lobe-chat/commit/7cca60f))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.22](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.21...v2.0.0-next.22)
 
 <sup>Released on **2025-11-04**</sup>

package/apps/desktop/package.json

@@ -72,7 +72,7 @@
     "tsx": "^4.19.3",
     "typescript": "^5.7.3",
     "undici": "^7.9.0",
-    "vite": "^7.1.12",
+    "vite": "^6.3.5",
     "vitest": "^3.2.4"
   },
   "pnpm": {

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Fix send message."
+      ]
+    },
+    "date": "2025-11-04",
+    "version": "2.0.0-next.23"
+  },
   {
     "children": {},
     "date": "2025-11-04",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.22",
+  "version": "2.0.0-next.23",
   "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/memory-extract/package.json

@@ -10,7 +10,7 @@
     "@lobechat/model-runtime": "workspace:*",
     "@lobechat/prompts": "workspace:*",
     "dotenv": "^17.2.3",
-    "ora": "^8.2.0"
+    "ora": "^9.0.0"
   },
   "devDependencies": {
     "tsx": "^4.19.2"

package/packages/types/src/message/ui/params.ts

@@ -130,10 +130,10 @@ export const CreateMessageParamsSchema = z
     files: z.array(z.string()).optional(),
     fromModel: z.string().optional(),
     fromProvider: z.string().optional(),
-    groupId: z.string().optional(),
+    groupId: z.string().nullable().optional(),
     targetId: z.string().nullable().optional(),
     threadId: z.string().nullable().optional(),
-    topicId: z.string().optional(),
+    topicId: z.string().nullable().optional(),
     traceId: z.string().optional(),
     // Allow additional fields from UIChatMessage (many can be null)
     agentId: z.string().optional(),
@@ -182,7 +182,7 @@ export const CreateNewMessageParamsSchema = z
     parentId: z.string().optional(),
     groupId: z.string().nullable().optional(),
     // Context
-    topicId: z.string().optional(),
+    topicId: z.string().nullable().optional(),
     threadId: z.string().nullable().optional(),
     targetId: z.string().nullable().optional(),
     // Model info

package/renovate.json

@@ -15,28 +15,64 @@
     "workarounds:all"
   ],
   "ignoreDeps": [],
-  "labels": [
-    "dependencies"
-  ],
+  "labels": ["dependencies"],
   "packageRules": [
+    // 1) Pinned deps: isolate (OK to use separate* here because there's no matchUpdateTypes)
+    {
+      "description": "Isolate PRs for pinned deps (exact x.y.z)",
+      "matchManagers": ["npm", "pnpm", "yarn", "bun"],
+      "matchDepTypes": [
+        "dependencies",
+        "devDependencies",
+        "optionalDependencies",
+        "peerDependencies"
+      ],
+      "matchCurrentValue": "^\\d+\\.\\d+\\.\\d+([+-][0-9A-Za-z.-]+)?$",
+      "groupName": null,
+      "separateMinorPatch": true,
+      "separateMajorMinor": true,
+      "separateMultipleMinor": true,
+      "separateMultipleMajor": true
+    },
+    // 2a) Non-pinned deps: override splitting so patch+minor can be combined
     {
-      "groupName": "all non-minor dependencies",
-      "groupSlug": "all-minor-patch",
-      "matchPackageNames": [
-        "*"
+      "description": "Non-pinned deps: allow patch+minor to group; keep majors separate",
+      "matchManagers": ["npm", "pnpm", "yarn", "bun"],
+      "matchDepTypes": [
+        "dependencies",
+        "devDependencies",
+        "optionalDependencies",
+        "peerDependencies"
       ],
-      "matchUpdateTypes": [
-        "patch"
-      ]
+      "matchCurrentValue": "/(^[~^]|[<>=| -])/", // anything that looks like a range
+      "separateMinorPatch": false,
+      "separateMajorMinor": true
+    },
+    // 2b) Non-pinned deps: actually group patch+minor together
+    {
+      "description": "Non-pinned deps: group non-major updates",
+      "matchManagers": ["npm", "pnpm", "yarn", "bun"],
+      "matchDepTypes": [
+        "dependencies",
+        "devDependencies",
+        "optionalDependencies",
+        "peerDependencies"
+      ],
+      "matchCurrentValue": "/(^[~^]|[<>=| -])/",
+      "matchUpdateTypes": ["minor", "patch"], // only non-majors
+      "groupName": "deps (non-major)"
     }
   ],
-  "postUpdateOptions": [
-    "yarnDedupeHighest"
-  ],
+  "postUpdateOptions": ["yarnDedupeHighest"],
   "prConcurrentLimit": 30,
   "prHourlyLimit": 0,
   "rangeStrategy": "bump",
   "rebaseWhen": "conflicted",
   "schedule": "on sunday before 6:00am",
+  "separateMajorMinor": true,
+  // Global defaults are fine; rule 2a overrides minor/patch splitting for ranged deps
+  "separateMinorPatch": true,
+  "separateMultipleMajor": true,
+  "separateMultipleMinor": true,
   "timezone": "UTC"
 }

package/src/server/services/mcp/deps/MCPSystemDepsCheckService.test.ts

@@ -0,0 +1,541 @@
+import { DeploymentOption, SystemDependency } from '@lobehub/market-sdk';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+// Import after mock setup
+import { mcpSystemDepsCheckService } from './MCPSystemDepsCheckService';
+import { InstallationChecker } from './types';
+
+// Hoist the mock to ensure it's available in the factory
+const { mockExecPromise } = vi.hoisted(() => {
+  return {
+    mockExecPromise: vi.fn(),
+  };
+});
+
+// Mock node:child_process
+vi.mock('node:child_process');
+
+// Mock node:util to return our hoisted mock when promisify is called
+vi.mock('node:util', () => ({
+  default: {
+    promisify: () => mockExecPromise,
+  },
+  promisify: () => mockExecPromise,
+}));
+
+describe('MCPSystemDepsCheckService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('registerChecker', () => {
+    it('should register an installation checker', () => {
+      const mockChecker: InstallationChecker = {
+        checkPackageInstalled: vi.fn(),
+      };
+
+      mcpSystemDepsCheckService.registerChecker('npm', mockChecker);
+
+      // Verify checker is registered by using it in checkDeployOption
+      expect(() => mcpSystemDepsCheckService.registerChecker('npm', mockChecker)).not.toThrow();
+    });
+  });
+
+  describe('checkSystemDependency', () => {
+    it('should successfully check installed dependency without version requirement', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'node',
+        checkCommand: 'node --version',
+      };
+
+      mockExecPromise.mockResolvedValue({ stdout: 'v18.16.0\n', stderr: '' });
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result).toEqual({
+        installed: true,
+        meetRequirement: true,
+        name: 'node',
+        requiredVersion: undefined,
+        version: 'v18.16.0',
+        installInstructions: undefined,
+      });
+    });
+
+    it('should parse version when versionParsingRequired is true', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'python',
+        checkCommand: 'python --version',
+        versionParsingRequired: true,
+      };
+
+      mockExecPromise.mockResolvedValue({ stdout: 'Python 3.10.5\n', stderr: '' });
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.version).toBe('3.10.5');
+      expect(result.installed).toBe(true);
+    });
+
+    it('should handle version with v prefix in parsing', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'node',
+        checkCommand: 'node --version',
+        versionParsingRequired: true,
+      };
+
+      mockExecPromise.mockResolvedValue({ stdout: 'v20.1.0\n', stderr: '' });
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.version).toBe('v20.1.0');
+      expect(result.installed).toBe(true);
+    });
+
+    it('should check version with >= operator', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'node',
+        checkCommand: 'node --version',
+        requiredVersion: '>=18.0.0',
+        versionParsingRequired: true,
+      };
+
+      mockExecPromise.mockResolvedValue({ stdout: 'v20.1.0\n', stderr: '' });
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.meetRequirement).toBe(true);
+      expect(result.installed).toBe(true);
+      expect(result.version).toBe('v20.1.0');
+    });
+
+    it('should fail version check with >= operator when version is lower', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'node',
+        checkCommand: 'node --version',
+        requiredVersion: '>=20.0.0',
+        versionParsingRequired: true,
+      };
+
+      mockExecPromise.mockResolvedValue({ stdout: 'v18.16.0\n', stderr: '' });
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.meetRequirement).toBe(false);
+      expect(result.installed).toBe(true);
+    });
+
+    it('should check version with > operator', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'python',
+        checkCommand: 'python --version',
+        requiredVersion: '>3.0.0',
+        versionParsingRequired: true,
+      };
+
+      mockExecPromise.mockResolvedValue({ stdout: 'Python 3.10.5\n', stderr: '' });
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.meetRequirement).toBe(true);
+    });
+
+    it('should check version with <= operator', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'tool',
+        checkCommand: 'tool --version',
+        requiredVersion: '<=2.0.0',
+        versionParsingRequired: true,
+      };
+
+      mockExecPromise.mockResolvedValue({ stdout: '1.5.0\n', stderr: '' });
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.meetRequirement).toBe(true);
+    });
+
+    it('should check version with < operator', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'tool',
+        checkCommand: 'tool --version',
+        requiredVersion: '<2.0.0',
+        versionParsingRequired: true,
+      };
+
+      mockExecPromise.mockResolvedValue({ stdout: '2.5.0\n', stderr: '' });
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.meetRequirement).toBe(false);
+    });
+
+    it('should check version with = operator (default)', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'tool',
+        checkCommand: 'tool --version',
+        requiredVersion: '3.0.0',
+        versionParsingRequired: true,
+      };
+
+      mockExecPromise.mockResolvedValue({ stdout: '3.0.0\n', stderr: '' });
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.meetRequirement).toBe(true);
+    });
+
+    it('should use default check command when not provided', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'git',
+      };
+
+      mockExecPromise.mockResolvedValue({ stdout: 'git version 2.39.0\n', stderr: '' });
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.installed).toBe(true);
+    });
+
+    it('should handle stderr without stdout as error', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'invalid-tool',
+        checkCommand: 'invalid-tool --version',
+      };
+
+      mockExecPromise.mockResolvedValue({ stdout: '', stderr: 'command not found' });
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.installed).toBe(false);
+      expect(result.meetRequirement).toBe(false);
+      expect(result.error).toBe('command not found');
+    });
+
+    it('should handle command execution error', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'missing-tool',
+        checkCommand: 'missing-tool --version',
+      };
+
+      mockExecPromise.mockRejectedValue(new Error('command not found'));
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.installed).toBe(false);
+      expect(result.meetRequirement).toBe(false);
+      expect(result.error).toBe('command not found');
+    });
+
+    it('should handle unknown error types', async () => {
+      const mockDependency: SystemDependency = {
+        name: 'tool',
+        checkCommand: 'tool --version',
+      };
+
+      mockExecPromise.mockRejectedValue('string error');
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.installed).toBe(false);
+      expect(result.error).toBe('Unknown error');
+    });
+
+    it('should include install instructions on macOS', async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, 'platform', {
+        value: 'darwin',
+      });
+
+      const mockDependency: SystemDependency = {
+        name: 'brew',
+        checkCommand: 'brew --version',
+        installInstructions: {
+          macos: 'Install via Homebrew',
+          linux: 'Use apt-get',
+          manual: 'Download from website',
+        },
+      } as any;
+
+      mockExecPromise.mockRejectedValue(new Error('not found'));
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.installInstructions).toEqual({
+        current: 'Install via Homebrew',
+        manual: 'Download from website',
+      });
+
+      Object.defineProperty(process, 'platform', {
+        value: originalPlatform,
+      });
+    });
+
+    it('should include install instructions on Linux', async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, 'platform', {
+        value: 'linux',
+      });
+
+      const mockDependency: SystemDependency = {
+        name: 'tool',
+        checkCommand: 'tool --version',
+        installInstructions: {
+          linux_debian: 'apt-get install tool',
+          manual: 'Manual install',
+        },
+      } as any;
+
+      mockExecPromise.mockRejectedValue(new Error('not found'));
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.installInstructions).toEqual({
+        current: 'apt-get install tool',
+        manual: 'Manual install',
+      });
+
+      Object.defineProperty(process, 'platform', {
+        value: originalPlatform,
+      });
+    });
+
+    it('should fallback to linux instruction when linux_debian is not available', async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, 'platform', {
+        value: 'linux',
+      });
+
+      const mockDependency: SystemDependency = {
+        name: 'tool',
+        checkCommand: 'tool --version',
+        installInstructions: {
+          linux: 'Generic linux install',
+          manual: 'Manual install',
+        },
+      } as any;
+
+      mockExecPromise.mockRejectedValue(new Error('not found'));
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.installInstructions?.current).toBe('Generic linux install');
+
+      Object.defineProperty(process, 'platform', {
+        value: originalPlatform,
+      });
+    });
+
+    it('should include install instructions on Windows', async () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, 'platform', {
+        value: 'win32',
+      });
+
+      const mockDependency: SystemDependency = {
+        name: 'tool',
+        checkCommand: 'tool --version',
+        installInstructions: {
+          windows: 'Install via Chocolatey',
+          manual: 'Download from website',
+        },
+      } as any;
+
+      mockExecPromise.mockRejectedValue(new Error('not found'));
+
+      const result = await mcpSystemDepsCheckService.checkSystemDependency(mockDependency);
+
+      expect(result.installInstructions).toEqual({
+        current: 'Install via Chocolatey',
+        manual: 'Download from website',
+      });
+
+      Object.defineProperty(process, 'platform', {
+        value: originalPlatform,
+      });
+    });
+  });
+
+  describe('checkDeployOption', () => {
+    it('should use installation checker when available', async () => {
+      const mockChecker: InstallationChecker = {
+        checkPackageInstalled: vi.fn().mockResolvedValue({
+          installed: true,
+          packageName: 'test-package',
+        }),
+      };
+
+      mcpSystemDepsCheckService.registerChecker('npm', mockChecker);
+
+      const mockOption: DeploymentOption = {
+        installationMethod: 'npm',
+        installationDetails: { packageName: 'test-package' },
+        connection: {
+          command: 'node',
+          args: ['index.js'],
+        },
+      } as any;
+
+      const result = await mcpSystemDepsCheckService.checkDeployOption(mockOption);
+
+      expect(mockChecker.checkPackageInstalled).toHaveBeenCalledWith({
+        packageName: 'test-package',
+      });
+      expect(result.packageInstalled).toBe(true);
+    });
+
+    it('should set connection type to http when url is provided', async () => {
+      const mockOption: DeploymentOption = {
+        installationMethod: 'manual',
+        installationDetails: {},
+        connection: {
+          url: 'http://localhost:3000',
+        },
+      } as any;
+
+      const result = await mcpSystemDepsCheckService.checkDeployOption(mockOption);
+
+      expect(result.connection.type).toBe('http');
+      expect(result.connection.url).toBe('http://localhost:3000');
+    });
+
+    it('should detect configuration requirements from required array', async () => {
+      const mockOption: DeploymentOption = {
+        installationMethod: 'npm',
+        installationDetails: { packageName: 'test-package' },
+        connection: {
+          command: 'node',
+          args: ['index.js'],
+          configSchema: {
+            type: 'object',
+            required: ['apiKey'],
+            properties: {
+              apiKey: { type: 'string' },
+            },
+          },
+        },
+      } as any;
+
+      const result = await mcpSystemDepsCheckService.checkDeployOption(mockOption);
+
+      expect(result.needsConfig).toBe(true);
+      expect(result.configSchema).toBeDefined();
+    });
+
+    it('should detect configuration requirements from property-level required flag', async () => {
+      const mockOption: DeploymentOption = {
+        installationMethod: 'npm',
+        installationDetails: { packageName: 'test-package' },
+        connection: {
+          command: 'node',
+          args: ['index.js'],
+          configSchema: {
+            type: 'object',
+            properties: {
+              apiKey: { type: 'string', required: true },
+            },
+          },
+        },
+      } as any;
+
+      const result = await mcpSystemDepsCheckService.checkDeployOption(mockOption);
+
+      expect(result.needsConfig).toBe(true);
+    });
+
+    it('should not require config when schema has no required fields', async () => {
+      const mockOption: DeploymentOption = {
+        installationMethod: 'npm',
+        installationDetails: { packageName: 'test-package' },
+        connection: {
+          command: 'node',
+          args: ['index.js'],
+          configSchema: {
+            type: 'object',
+            properties: {
+              optional: { type: 'string' },
+            },
+          },
+        },
+      } as any;
+
+      const result = await mcpSystemDepsCheckService.checkDeployOption(mockOption);
+
+      expect(result.needsConfig).toBe(false);
+    });
+
+    it('should not require config when schema has empty required array', async () => {
+      const mockOption: DeploymentOption = {
+        installationMethod: 'npm',
+        installationDetails: { packageName: 'test-package' },
+        connection: {
+          command: 'node',
+          args: ['index.js'],
+          configSchema: {
+            type: 'object',
+            required: [],
+            properties: {
+              optional: { type: 'string' },
+            },
+          },
+        },
+      } as any;
+
+      const result = await mcpSystemDepsCheckService.checkDeployOption(mockOption);
+
+      expect(result.needsConfig).toBe(false);
+    });
+
+    it('should include isRecommended flag from deployment option', async () => {
+      const mockOption: DeploymentOption = {
+        installationMethod: 'npm',
+        installationDetails: { packageName: 'test-package' },
+        isRecommended: true,
+        connection: {
+          command: 'node',
+          args: ['index.js'],
+        },
+      } as any;
+
+      const result = await mcpSystemDepsCheckService.checkDeployOption(mockOption);
+
+      expect(result.isRecommended).toBe(true);
+    });
+
+    it('should handle multiple system dependencies', async () => {
+      const mockOption: DeploymentOption = {
+        installationMethod: 'npm',
+        installationDetails: { packageName: 'test-package' },
+        systemDependencies: [
+          {
+            name: 'node',
+            checkCommand: 'node --version',
+            requiredVersion: '>=18.0.0',
+            versionParsingRequired: true,
+          },
+          {
+            name: 'python',
+            checkCommand: 'python --version',
+            requiredVersion: '>=3.0.0',
+            versionParsingRequired: true,
+          },
+        ],
+        connection: {
+          command: 'node',
+          args: ['index.js'],
+        },
+      } as any;
+
+      mockExecPromise
+        .mockResolvedValueOnce({ stdout: 'v20.1.0\n', stderr: '' })
+        .mockResolvedValueOnce({ stdout: 'Python 3.10.5\n', stderr: '' });
+
+      const result = await mcpSystemDepsCheckService.checkDeployOption(mockOption);
+
+      expect(result.systemDependencies).toHaveLength(2);
+      expect(result.allDependenciesMet).toBe(true);
+      expect(result.systemDependencies[0]!.name).toBe('node');
+      expect(result.systemDependencies[1]!.name).toBe('python');
+    });
+  });
+});