@lobehub/lobehub 2.0.0-next.33 → 2.0.0-next.35

package/src/app/[variants]/(main)/settings/provider/ProviderMenu/List.tsx

@@ -1,19 +1,29 @@
 'use client';
 
-import { ActionIcon, ScrollShadow, Text } from '@lobehub/ui';
+import { ActionIcon, Dropdown, Icon, ScrollShadow, Text } from '@lobehub/ui';
+import type { ItemType } from 'antd/es/menu/interface';
 import isEqual from 'fast-deep-equal';
-import { ArrowDownUpIcon } from 'lucide-react';
-import { useState } from 'react';
+import { ArrowDownUpIcon, LucideCheck } from 'lucide-react';
+import { useCallback, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
 
 import { aiProviderSelectors } from '@/store/aiInfra';
 import { useAiInfraStore } from '@/store/aiInfra/store';
+import { useGlobalStore } from '@/store/global';
+import { systemStatusSelectors } from '@/store/global/selectors';
 
 import All from './All';
 import ProviderItem from './Item';
 import SortProviderModal from './SortProviderModal';
 
+// Sort type enumeration
+enum SortType {
+  Alphabetical = 'alphabetical',
+  AlphabeticalDesc = 'alphabeticalDesc',
+  Default = 'default',
+}
+
 const ProviderList = (props: {
   mobile?: boolean;
   onProviderSelect: (providerKey: string) => void;
@@ -21,6 +31,19 @@ const ProviderList = (props: {
   const { onProviderSelect, mobile } = props;
   const { t } = useTranslation('modelProvider');
   const [open, setOpen] = useState(false);
+
+  const [sortType, updateSystemStatus] = useGlobalStore((s) => [
+    systemStatusSelectors.disabledModelProvidersSortType(s),
+    s.updateSystemStatus,
+  ]);
+
+  const updateSortType = useCallback(
+    (newSortType: SortType) => {
+      updateSystemStatus({ disabledModelProvidersSortType: newSortType });
+    },
+    [updateSystemStatus],
+  );
+
   const enabledModelProviderList = useAiInfraStore(
     aiProviderSelectors.enabledAiProviderList,
     isEqual,
@@ -30,6 +53,34 @@ const ProviderList = (props: {
     aiProviderSelectors.disabledAiProviderList,
     isEqual,
   );
+
+  // Sort model providers based on sort type
+  const sortedDisabledProviders = useMemo(() => {
+    const providers = [...disabledModelProviderList];
+    switch (sortType) {
+      case SortType.Alphabetical: {
+        return providers.sort((a, b) => {
+          const cmpDisplay = (a.name || a.id).localeCompare(b.name || b.id);
+          if (cmpDisplay !== 0) return cmpDisplay;
+          return a.id.localeCompare(b.id);
+        });
+      }
+      case SortType.AlphabeticalDesc: {
+        return providers.sort((a, b) => {
+          const cmpDisplay = (b.name || a.id).localeCompare(a.name || b.id);
+          if (cmpDisplay !== 0) return cmpDisplay;
+          return b.id.localeCompare(a.id);
+        });
+      }
+      case SortType.Default: {
+        return providers;
+      }
+      default: {
+        return providers;
+      }
+    }
+  }, [disabledModelProviderList, sortType]);
+
   return (
     <ScrollShadow gap={4} height={'100%'} paddingInline={12} size={4} style={{ paddingBottom: 32 }}>
       {!mobile && <All onClick={onProviderSelect} />}
@@ -63,10 +114,49 @@ const ProviderList = (props: {
       {enabledModelProviderList.map((item) => (
         <ProviderItem {...item} key={item.id} onClick={onProviderSelect} />
       ))}
-      <Text style={{ fontSize: 12, marginTop: 8 }} type={'secondary'}>
-        {t('menu.list.disabled')}
-      </Text>
-      {disabledModelProviderList.map((item) => (
+      <Flexbox align={'center'} horizontal justify={'space-between'}>
+        <Text style={{ fontSize: 12, marginTop: 8 }} type={'secondary'}>
+          {t('menu.list.disabled')}
+        </Text>
+        {disabledModelProviderList.length > 1 && (
+          <Dropdown
+            menu={{
+              items: [
+                {
+                  icon: sortType === SortType.Default ? <Icon icon={LucideCheck} /> : <div />,
+                  key: 'default',
+                  label: t('menu.list.disabledActions.sortDefault'),
+                  onClick: () => updateSortType(SortType.Default),
+                },
+                {
+                  type: 'divider',
+                },
+                {
+                  icon: sortType === SortType.Alphabetical ? <Icon icon={LucideCheck} /> : <div />,
+                  key: 'alphabetical',
+                  label: t('menu.list.disabledActions.sortAlphabetical'),
+                  onClick: () => updateSortType(SortType.Alphabetical),
+                },
+                {
+                  icon:
+                    sortType === SortType.AlphabeticalDesc ? <Icon icon={LucideCheck} /> : <div />,
+                  key: 'alphabeticalDesc',
+                  label: t('menu.list.disabledActions.sortAlphabeticalDesc'),
+                  onClick: () => updateSortType(SortType.AlphabeticalDesc),
+                },
+              ] as ItemType[],
+            }}
+            trigger={['click']}
+          >
+            <ActionIcon
+              icon={ArrowDownUpIcon}
+              size={'small'}
+              title={t('menu.list.disabledActions.sort')}
+            />
+          </Dropdown>
+        )}
+      </Flexbox>
+      {sortedDisabledProviders.map((item) => (
         <ProviderItem {...item} key={item.id} onClick={onProviderSelect} />
       ))}
     </ScrollShadow>

package/src/app/[variants]/(main)/settings/provider/features/ModelList/DisabledModels.tsx

@@ -1,12 +1,15 @@
-import { Button, Text } from '@lobehub/ui';
+import { ActionIcon, Button, Dropdown, Icon, Text } from '@lobehub/ui';
+import type { ItemType } from 'antd/es/menu/interface';
 import isEqual from 'fast-deep-equal';
-import { ChevronDown } from 'lucide-react';
-import { memo, useMemo, useState } from 'react';
+import { ArrowDownUpIcon, ChevronDown, LucideCheck } from 'lucide-react';
+import { memo, useCallback, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
 
 import { useAiInfraStore } from '@/store/aiInfra';
 import { aiModelSelectors } from '@/store/aiInfra/selectors';
+import { useGlobalStore } from '@/store/global';
+import { systemStatusSelectors } from '@/store/global/selectors';
 
 import ModelItem from './ModelItem';
 
@@ -14,10 +17,32 @@ interface DisabledModelsProps {
   activeTab: string;
 }
 
+// Sort type enumeration
+enum SortType {
+  Alphabetical = 'alphabetical',
+  AlphabeticalDesc = 'alphabeticalDesc',
+  Default = 'default',
+  ReleasedAt = 'releasedAt',
+  ReleasedAtDesc = 'releasedAtDesc',
+}
+
 const DisabledModels = memo<DisabledModelsProps>(({ activeTab }) => {
   const { t } = useTranslation('modelProvider');
 
   const [showMore, setShowMore] = useState(false);
+
+  const [sortType, updateSystemStatus] = useGlobalStore((s) => [
+    systemStatusSelectors.disabledModelsSortType(s),
+    s.updateSystemStatus,
+  ]);
+
+  const updateSortType = useCallback(
+    (newSortType: SortType) => {
+      updateSystemStatus({ disabledModelsSortType: newSortType });
+    },
+    [updateSystemStatus],
+  );
+
   const disabledModels = useAiInfraStore(aiModelSelectors.disabledAiProviderModelList, isEqual);
 
   // Filter models based on active tab
@@ -26,18 +51,129 @@ const DisabledModels = memo<DisabledModelsProps>(({ activeTab }) => {
     return disabledModels.filter((model) => model.type === activeTab);
   }, [disabledModels, activeTab]);
 
-  const displayModels = showMore ? filteredDisabledModels : filteredDisabledModels.slice(0, 10);
+  // Sort models based on sort type
+  const sortedDisabledModels = useMemo(() => {
+    const models = [...filteredDisabledModels];
+    switch (sortType) {
+      case SortType.Alphabetical: {
+        return models.sort((a, b) => {
+          const cmpDisplay = (a.displayName || a.id).localeCompare(b.displayName || b.id);
+          if (cmpDisplay !== 0) return cmpDisplay;
+          return a.id.localeCompare(b.id);
+        });
+      }
+      case SortType.AlphabeticalDesc: {
+        return models.sort((a, b) => {
+          const cmpDisplay = (b.displayName || b.id).localeCompare(a.displayName || a.id);
+          if (cmpDisplay !== 0) return cmpDisplay;
+          return b.id.localeCompare(a.id);
+        });
+      }
+      case SortType.ReleasedAt: {
+        return models.sort((a, b) => {
+          const aHasDate = !!a.releasedAt;
+          const bHasDate = !!b.releasedAt;
+
+          if (aHasDate && !bHasDate) return -1;
+          if (!aHasDate && bHasDate) return 1;
+          if (!aHasDate && !bHasDate) return 0;
+
+          return a.releasedAt!.localeCompare(b.releasedAt!);
+        });
+      }
+      case SortType.ReleasedAtDesc: {
+        return models.sort((a, b) => {
+          const aHasDate = !!a.releasedAt;
+          const bHasDate = !!b.releasedAt;
+
+          if (aHasDate && !bHasDate) return -1;
+          if (!aHasDate && bHasDate) return 1;
+          if (!aHasDate && !bHasDate) return 0;
+
+          return b.releasedAt!.localeCompare(a.releasedAt!);
+        });
+      }
+      case SortType.Default: {
+        return models;
+      }
+      default: {
+        return models;
+      }
+    }
+  }, [filteredDisabledModels, sortType]);
+
+  const displayModels = showMore ? sortedDisabledModels : sortedDisabledModels.slice(0, 10);
 
   return (
     filteredDisabledModels.length > 0 && (
       <Flexbox>
-        <Text style={{ fontSize: 12, marginTop: 8 }} type={'secondary'}>
-          {t('providerModels.list.disabled')}
-        </Text>
+        <Flexbox align="center" horizontal justify="space-between">
+          <Text style={{ fontSize: 12, marginTop: 8 }} type={'secondary'}>
+            {t('providerModels.list.disabled')}
+          </Text>
+          {filteredDisabledModels.length > 1 && (
+            <Dropdown
+              menu={{
+                items: [
+                  {
+                    icon: sortType === SortType.Default ? <Icon icon={LucideCheck} /> : <div />,
+                    key: 'default',
+                    label: t('providerModels.list.disabledActions.sortDefault'),
+                    onClick: () => updateSortType(SortType.Default),
+                  },
+                  {
+                    type: 'divider',
+                  },
+                  {
+                    icon:
+                      sortType === SortType.Alphabetical ? <Icon icon={LucideCheck} /> : <div />,
+                    key: 'alphabetical',
+                    label: t('providerModels.list.disabledActions.sortAlphabetical'),
+                    onClick: () => updateSortType(SortType.Alphabetical),
+                  },
+                  {
+                    icon:
+                      sortType === SortType.AlphabeticalDesc ? (
+                        <Icon icon={LucideCheck} />
+                      ) : (
+                        <div />
+                      ),
+                    key: 'alphabeticalDesc',
+                    label: t('providerModels.list.disabledActions.sortAlphabeticalDesc'),
+                    onClick: () => updateSortType(SortType.AlphabeticalDesc),
+                  },
+                  {
+                    type: 'divider',
+                  },
+                  {
+                    icon: sortType === SortType.ReleasedAt ? <Icon icon={LucideCheck} /> : <div />,
+                    key: 'releasedAt',
+                    label: t('providerModels.list.disabledActions.sortReleasedAt'),
+                    onClick: () => updateSortType(SortType.ReleasedAt),
+                  },
+                  {
+                    icon:
+                      sortType === SortType.ReleasedAtDesc ? <Icon icon={LucideCheck} /> : <div />,
+                    key: 'releasedAtDesc',
+                    label: t('providerModels.list.disabledActions.sortReleasedAtDesc'),
+                    onClick: () => updateSortType(SortType.ReleasedAtDesc),
+                  },
+                ] as ItemType[],
+              }}
+              trigger={['click']}
+            >
+              <ActionIcon
+                icon={ArrowDownUpIcon}
+                size={'small'}
+                title={t('providerModels.list.disabledActions.sort')}
+              />
+            </Dropdown>
+          )}
+        </Flexbox>
         {displayModels.map((item) => (
           <ModelItem {...item} key={item.id} />
         ))}
-        {!showMore && filteredDisabledModels.length > 10 && (
+        {!showMore && sortedDisabledModels.length > 10 && (
           <Button
             block
             icon={ChevronDown}

package/src/features/Portal/GroupThread/Body/index.tsx

@@ -3,7 +3,7 @@
 import { memo } from 'react';
 import { Flexbox } from 'react-layout-kit';
 
-import ChatInput from '@/app/[variants]/(main)/chat/(workspace)/@conversation/features/ChatInput';
+import ChatInput from '@/app/[variants]/(main)/chat/components/conversation/features/ChatInput';
 import { useChatGroupStore } from '@/store/chatGroup';
 
 import ThreadChatList from './ThreadChatList';

package/src/hooks/useHotkeys/chatScope.ts

@@ -2,7 +2,7 @@ import isEqual from 'fast-deep-equal';
 import { useEffect } from 'react';
 import { useHotkeysContext } from 'react-hotkeys-hook';
 
-import { useSend } from '@/app/[variants]/(main)/chat/(workspace)/@conversation/features/ChatInput/useSend';
+import { useSend } from '@/app/[variants]/(main)/chat/components/conversation/features/ChatInput/useSend';
 import { useClearCurrentMessages } from '@/features/ChatInput/ActionBar/Clear';
 import { useOpenChatSettings } from '@/hooks/useInterceptingRoutes';
 import { useActionSWR } from '@/libs/swr';

package/src/locales/default/modelProvider.ts

@@ -202,6 +202,12 @@ export default {
     all: '全部',
     list: {
       disabled: '未启用',
+      disabledActions: {
+        sort: '排序方式',
+        sortAlphabetical: '按字母排序',
+        sortAlphabeticalDesc: '按字母倒序排序',
+        sortDefault: '默认排序',
+      },
       enabled: '已启用',
     },
     notFound: '未找到搜索结果',
@@ -399,7 +405,15 @@ export default {
     list: {
       addNew: '添加模型',
       disabled: '未启用',
-      disabledActions: { showMore: '显示全部' },
+      disabledActions: {
+        showMore: '显示全部',
+        sort: '排序方式',
+        sortAlphabetical: '按字母排序',
+        sortAlphabeticalDesc: '按字母倒序排序',
+        sortDefault: '默认排序',
+        sortReleasedAt: '按最早发布时间排序',
+        sortReleasedAtDesc: '按最新发布时间排序',
+      },
       empty: {
         desc: '请创建自定义模型或拉取模型后开始使用吧',
         title: '暂无可用模型',

package/src/server/services/mcp/deps/checkers/ManualInstallationChecker.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from 'vitest';
+
+import { ManualInstallationChecker } from './ManualInstallationChecker';
+
+describe('ManualInstallationChecker', () => {
+  let checker: ManualInstallationChecker;
+
+  beforeEach(() => {
+    checker = new ManualInstallationChecker();
+  });
+
+  describe('checkPackageInstalled', () => {
+    it('should always return not installed for manual packages', async () => {
+      const result = await checker.checkPackageInstalled({ packageName: 'manual-package' });
+
+      expect(result).toEqual({
+        installed: false,
+        packageName: 'manual-package',
+      });
+    });
+
+    it('should handle packageName with repository URL', async () => {
+      const result = await checker.checkPackageInstalled({
+        packageName: 'my-custom-tool',
+        repositoryUrlToClone: 'https://github.com/user/repo.git',
+      });
+
+      expect(result.installed).toBe(false);
+      expect(result.packageName).toBe('my-custom-tool');
+    });
+
+    it('should use repositoryUrlToClone as packageName when packageName is not provided', async () => {
+      const result = await checker.checkPackageInstalled({
+        repositoryUrlToClone: 'https://github.com/user/custom-tool.git',
+      });
+
+      expect(result).toEqual({
+        installed: false,
+        packageName: 'https://github.com/user/custom-tool.git',
+      });
+    });
+
+    it('should return empty packageName when neither packageName nor repositoryUrlToClone provided', async () => {
+      const result = await checker.checkPackageInstalled({});
+
+      expect(result).toEqual({
+        installed: false,
+        packageName: '',
+      });
+    });
+
+    it('should handle undefined packageName', async () => {
+      const result = await checker.checkPackageInstalled({ packageName: undefined });
+
+      expect(result).toEqual({
+        installed: false,
+        packageName: '',
+      });
+    });
+
+    it('should handle empty string packageName', async () => {
+      const result = await checker.checkPackageInstalled({ packageName: '' });
+
+      expect(result).toEqual({
+        installed: false,
+        packageName: '',
+      });
+    });
+
+    it('should handle empty string repositoryUrlToClone as fallback', async () => {
+      const result = await checker.checkPackageInstalled({
+        packageName: '',
+        repositoryUrlToClone: '',
+      });
+
+      expect(result).toEqual({
+        installed: false,
+        packageName: '',
+      });
+    });
+
+    it('should prioritize packageName over repositoryUrlToClone', async () => {
+      const result = await checker.checkPackageInstalled({
+        packageName: 'my-tool',
+        repositoryUrlToClone: 'https://github.com/user/repo.git',
+      });
+
+      expect(result.packageName).toBe('my-tool');
+      expect(result.installed).toBe(false);
+    });
+
+    it('should handle complex package names', async () => {
+      const result = await checker.checkPackageInstalled({
+        packageName: '@scope/package-name-with-special.chars_123',
+      });
+
+      expect(result).toEqual({
+        installed: false,
+        packageName: '@scope/package-name-with-special.chars_123',
+      });
+    });
+
+    it('should handle SSH repository URLs', async () => {
+      const result = await checker.checkPackageInstalled({
+        repositoryUrlToClone: 'git@github.com:user/repo.git',
+      });
+
+      expect(result).toEqual({
+        installed: false,
+        packageName: 'git@github.com:user/repo.git',
+      });
+    });
+
+    it('should handle local file paths', async () => {
+      const result = await checker.checkPackageInstalled({
+        packageName: '/usr/local/custom-tool',
+      });
+
+      expect(result).toEqual({
+        installed: false,
+        packageName: '/usr/local/custom-tool',
+      });
+    });
+
+    it('should handle Windows-style paths', async () => {
+      const result = await checker.checkPackageInstalled({
+        packageName: 'C:\\Program Files\\CustomTool',
+      });
+
+      expect(result).toEqual({
+        installed: false,
+        packageName: 'C:\\Program Files\\CustomTool',
+      });
+    });
+
+    it('should handle package names with unicode characters', async () => {
+      const result = await checker.checkPackageInstalled({
+        packageName: 'my-tool-日本語',
+      });
+
+      expect(result).toEqual({
+        installed: false,
+        packageName: 'my-tool-日本語',
+      });
+    });
+
+    it('should always return false for installed regardless of input', async () => {
+      const testCases = [
+        { packageName: 'package1' },
+        { packageName: 'package2', repositoryUrlToClone: 'https://example.com/repo.git' },
+        { repositoryUrlToClone: 'https://example.com/repo2.git' },
+        {},
+        { packageName: '' },
+      ];
+
+      for (const testCase of testCases) {
+        const result = await checker.checkPackageInstalled(testCase);
+        expect(result.installed).toBe(false);
+      }
+    });
+  });
+});