@lobehub/lobehub 2.0.0-next.3 → 2.0.0-next.31

package/src/server/routers/lambda/user.ts

@@ -1,9 +1,17 @@
 import { UserJSON } from '@clerk/backend';
+import { enableClerk, isDesktop } from '@lobechat/const';
+import {
+  NextAuthAccountSchame,
+  UserGuideSchema,
+  UserInitializationState,
+  UserPreference,
+  UserPreferenceSchema,
+  UserSettings,
+  UserSettingsSchema,
+} from '@lobechat/types';
 import { v4 as uuidv4 } from 'uuid';
 import { z } from 'zod';
 
-import { enableClerk } from '@/const/auth';
-import { isDesktop } from '@/const/version';
 import { MessageModel } from '@/database/models/message';
 import { SessionModel } from '@/database/models/session';
 import { UserModel, UserNotFoundError } from '@/database/models/user';
@@ -16,20 +24,15 @@ import { S3 } from '@/server/modules/S3';
 import { FileService } from '@/server/services/file';
 import { NextAuthUserService } from '@/server/services/nextAuthUser';
 import { UserService } from '@/server/services/user';
-import {
-  NextAuthAccountSchame,
-  UserGuideSchema,
-  UserInitializationState,
-  UserPreference,
-} from '@/types/user';
-import { UserSettings } from '@/types/user/settings';
 
 const userProcedure = authedProcedure.use(serverDatabase).use(async ({ ctx, next }) => {
   return next({
     ctx: {
       clerkAuth: new ClerkAuth(),
       fileService: new FileService(ctx.serverDB, ctx.userId),
+      messageModel: new MessageModel(ctx.serverDB, ctx.userId),
       nextAuthUserService: new NextAuthUserService(ctx.serverDB),
+      sessionModel: new SessionModel(ctx.serverDB, ctx.userId),
       userModel: new UserModel(ctx.serverDB, ctx.userId),
     },
   });
@@ -96,12 +99,12 @@ export const userRouter = router({
       }
     }
 
-    const messageModel = new MessageModel(ctx.serverDB, ctx.userId);
-    const hasMoreThan4Messages = await messageModel.hasMoreThanN(4);
-
-    const sessionModel = new SessionModel(ctx.serverDB, ctx.userId);
-    const hasAnyMessages = await messageModel.hasMoreThanN(0);
-    const hasExtraSession = await sessionModel.hasMoreThanN(1);
+    // Run all count queries in parallel
+    const [hasMoreThan4Messages, hasAnyMessages, hasExtraSession] = await Promise.all([
+      ctx.messageModel.hasMoreThanN(4),
+      ctx.messageModel.hasMoreThanN(0),
+      ctx.sessionModel.hasMoreThanN(1),
+    ]);
 
     return {
       avatar: state.avatar,
@@ -199,30 +202,28 @@ export const userRouter = router({
     return ctx.userModel.updateGuide(input);
   }),
 
-  updatePreference: userProcedure.input(z.any()).mutation(async ({ ctx, input }) => {
+  updatePreference: userProcedure.input(UserPreferenceSchema).mutation(async ({ ctx, input }) => {
     return ctx.userModel.updatePreference(input);
   }),
 
-  updateSettings: userProcedure
-    .input(z.object({}).passthrough())
-    .mutation(async ({ ctx, input }) => {
-      const { keyVaults, ...res } = input as Partial<UserSettings>;
+  updateSettings: userProcedure.input(UserSettingsSchema).mutation(async ({ ctx, input }) => {
+    const { keyVaults, ...res } = input as Partial<UserSettings>;
 
-      // Encrypt keyVaults
-      let encryptedKeyVaults: string | null = null;
+    // Encrypt keyVaults
+    let encryptedKeyVaults: string | null = null;
 
-      if (keyVaults) {
-        // TODO: better to add a validation
-        const data = JSON.stringify(keyVaults);
-        const gateKeeper = await KeyVaultsGateKeeper.initWithEnvKey();
+    if (keyVaults) {
+      // TODO: better to add a validation
+      const data = JSON.stringify(keyVaults);
+      const gateKeeper = await KeyVaultsGateKeeper.initWithEnvKey();
 
-        encryptedKeyVaults = await gateKeeper.encrypt(data);
-      }
+      encryptedKeyVaults = await gateKeeper.encrypt(data);
+    }
 
-      const nextValue = { ...res, keyVaults: encryptedKeyVaults };
+    const nextValue = { ...res, keyVaults: encryptedKeyVaults };
 
-      return ctx.userModel.updateSetting(nextValue);
-    }),
+    return ctx.userModel.updateSetting(nextValue);
+  }),
 });
 
 export type UserRouter = typeof userRouter;

package/src/server/routers/tools/mcp.ts

@@ -1,3 +1,4 @@
+import { isDesktop } from '@lobechat/const';
 import {
   GetStreamableMcpServerManifestInputSchema,
   StreamableHTTPAuthSchema,
@@ -5,8 +6,6 @@ import {
 import { TRPCError } from '@trpc/server';
 import { z } from 'zod';
 
-import { isDesktop, isServerMode } from '@/const/version';
-import { passwordProcedure } from '@/libs/trpc/edge';
 import { authedProcedure, router } from '@/libs/trpc/lambda';
 import { mcpService } from '@/server/services/mcp';
 
@@ -38,7 +37,7 @@ const checkStdioEnvironment = (params: z.infer<typeof mcpClientParamsSchema>) =>
   }
 };
 
-const mcpProcedure = isServerMode ? authedProcedure : passwordProcedure;
+const mcpProcedure = authedProcedure;
 
 export const mcpRouter = router({
   getStreamableMcpServerManifest: mcpProcedure

package/src/server/routers/tools/search.test.ts

@@ -23,13 +23,7 @@ vi.mock('@/server/services/search/impls/searxng/client');
 
 describe('searchRouter', () => {
   const mockContext = {
-    req: {
-      headers: {
-        authorization: 'Bearer mock-token',
-      },
-    },
-    authorizationHeader: 'Bearer mock-token',
-    jwtPayload: { userId: '1' },
+    userId: 'test-user-id',
   };
 
   beforeEach(() => {

package/src/server/routers/tools/search.ts

@@ -1,12 +1,9 @@
-import { isServerMode } from '@lobechat/const';
 import { z } from 'zod';
 
-import { passwordProcedure } from '@/libs/trpc/edge';
 import { authedProcedure, router } from '@/libs/trpc/lambda';
 import { searchService } from '@/server/services/search';
 
-// TODO: password procedure 未来的处理方式可能要思考下
-const searchProcedure = isServerMode ? authedProcedure : passwordProcedure;
+const searchProcedure = authedProcedure;
 
 export const searchRouter = router({
   crawlPages: searchProcedure

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');
+    });
+  });
+});