@lobehub/chat 1.98.2 → 1.99.0

package/src/utils/url.test.ts

@@ -1,17 +1,20 @@
+import { vi } from 'vitest';
+
 import { pathString } from './url';
+import { inferContentTypeFromImageUrl, inferFileExtensionFromImageUrl } from './url';
 
 describe('pathString', () => {
-  it('基本情况', () => {
+  it('should handle basic path', () => {
     const result = pathString('/home');
     expect(result).toBe('/home');
   });
 
-  it('包含查询参数的情况', () => {
+  it('should handle path with search parameters', () => {
     const result = pathString('/home', { search: 'id=1&name=test' });
     expect(result).toBe('/home?id=1&name=test');
   });
 
-  it('包含哈希值的情况', () => {
+  it('should handle path with hash', () => {
     const result = pathString('/home', { hash: 'top' });
     expect(result).toBe('/home#top');
 
@@ -19,33 +22,379 @@ describe('pathString', () => {
     expect(result2).toBe('/home#hash=abc');
   });
 
-  it('path 参数包含相对路径的情况', () => {
+  it('should handle relative path', () => {
     const result = pathString('./home');
     expect(result).toBe('/home');
   });
 
-  it('path 参数包含绝对路径的情况', () => {
+  it('should handle absolute path', () => {
     const result = pathString('/home');
     expect(result).toBe('/home');
   });
 
-  it('path 参数包含协议的情况', () => {
+  it('should handle path with protocol', () => {
     const result = pathString('https://www.example.com/home');
     expect(result).toBe('https://www.example.com/home');
   });
 
-  it('path 参数包含主机名的情况', () => {
+  it('should handle path with hostname', () => {
     const result = pathString('//www.example.com/home');
     expect(result).toBe('https://www.example.com/home');
   });
 
-  it('path 参数包含端口号的情况', () => {
+  it('should handle path with port number', () => {
     const result = pathString('//www.example.com:8080/home');
     expect(result).toBe('https://www.example.com:8080/home');
   });
 
-  it('path 参数包含特殊字符的情况', () => {
+  it('should handle path with special characters', () => {
     const result = pathString('/home/测试');
     expect(result).toBe('/home/%E6%B5%8B%E8%AF%95');
   });
 });
+
+describe('inferContentTypeFromImageUrl', () => {
+  it('should return correct MIME type for jpg images', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/image.jpg');
+    expect(result).toBe('image/jpeg');
+  });
+
+  it('should return correct MIME type for png images', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/image.png');
+    expect(result).toBe('image/png');
+  });
+
+  it('should return correct MIME type for webp images', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/image.webp');
+    expect(result).toBe('image/webp');
+  });
+
+  it('should return correct MIME type for gif images', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/image.gif');
+    expect(result).toBe('image/gif');
+  });
+
+  it('should handle uppercase extensions', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/image.JPG');
+    expect(result).toBe('image/jpeg');
+  });
+
+  it('should handle URLs with query parameters', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/image.png?v=123&size=large');
+    expect(result).toBe('image/png');
+  });
+
+  it('should handle URLs with hash fragments', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/image.jpg#section');
+    expect(result).toBe('image/jpeg');
+  });
+
+  it('should throw error when no extension', () => {
+    expect(() => {
+      inferContentTypeFromImageUrl('https://example.com/image');
+    }).toThrow('Invalid image url: https://example.com/image');
+  });
+
+  it('should throw error when only dot without extension', () => {
+    expect(() => {
+      inferContentTypeFromImageUrl('https://example.com/image.');
+    }).toThrow('Invalid image url: https://example.com/image.');
+  });
+
+  it('should handle multiple dots in path', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/my.folder/image.test.png');
+    expect(result).toBe('image/png');
+  });
+
+  it('should handle complex query parameters and hash combination', () => {
+    const result = inferContentTypeFromImageUrl(
+      'https://example.com/image.jpeg?width=800&height=600&format=jpeg#preview',
+    );
+    expect(result).toBe('image/jpeg');
+  });
+
+  it('should handle mixed case extensions', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/image.JpEg');
+    expect(result).toBe('image/jpeg');
+  });
+
+  it('should handle BMP format', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/image.bmp');
+    expect(result).toBe('image/bmp');
+  });
+
+  it('should handle TIFF format', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/image.tiff');
+    expect(result).toBe('image/tiff');
+  });
+
+  it('should handle TIF format', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/image.tif');
+    expect(result).toBe('image/tiff');
+  });
+
+  it('should handle SVG format', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com/image.svg');
+    expect(result).toBe('image/svg+xml');
+  });
+
+  it('should throw error for invalid URLs', () => {
+    expect(() => {
+      inferContentTypeFromImageUrl('invalid-url');
+    }).toThrow('Invalid image url: invalid-url');
+  });
+
+  it('should throw error for empty string', () => {
+    expect(() => {
+      inferContentTypeFromImageUrl('');
+    }).toThrow('Invalid image url: ');
+  });
+
+  it('should throw error for non-image extensions', () => {
+    expect(() => {
+      inferContentTypeFromImageUrl('https://example.com/document.txt');
+    }).toThrow('Invalid image url: https://example.com/document.txt');
+  });
+
+  it('should throw error for unknown extensions', () => {
+    expect(() => {
+      inferContentTypeFromImageUrl('https://example.com/file.unknownext');
+    }).toThrow('Invalid image url: https://example.com/file.unknownext');
+  });
+
+  it('should handle URLs with port numbers', () => {
+    const result = inferContentTypeFromImageUrl('https://example.com:8080/image.png');
+    expect(result).toBe('image/png');
+  });
+
+  it('should handle deeply nested paths', () => {
+    const result = inferContentTypeFromImageUrl(
+      'https://cdn.example.com/assets/images/gallery/2024/photo.jpg',
+    );
+    expect(result).toBe('image/jpeg');
+  });
+
+  it('should handle encoded filenames', () => {
+    const result = inferContentTypeFromImageUrl(
+      'https://example.com/images/%E5%9B%BE%E7%89%87.png',
+    );
+    expect(result).toBe('image/png');
+  });
+
+  it('should handle protocol-relative URLs', () => {
+    const result = inferContentTypeFromImageUrl('//example.com/image.webp');
+    expect(result).toBe('image/webp');
+  });
+
+  it('should handle relative paths', () => {
+    const result = inferContentTypeFromImageUrl('generations/images/photo.jpg');
+    expect(result).toBe('image/jpeg');
+  });
+
+  it('should handle relative paths with complex filenames', () => {
+    const result = inferContentTypeFromImageUrl(
+      'generations/images/2NPfAQAMNxXPi82mzOHog_1056x1136_20250702_110911_raw.png',
+    );
+    expect(result).toBe('image/png');
+  });
+
+  it('should handle relative paths with query parameters', () => {
+    const result = inferContentTypeFromImageUrl('images/photo.webp?v=123');
+    expect(result).toBe('image/webp');
+  });
+
+  it('should handle relative paths with hash fragments', () => {
+    const result = inferContentTypeFromImageUrl('assets/images/banner.gif#preview');
+    expect(result).toBe('image/gif');
+  });
+
+  it('should throw error for single character extensions (if no valid MIME type)', () => {
+    expect(() => {
+      inferContentTypeFromImageUrl('https://example.com/file.x');
+    }).toThrow('Invalid image url: https://example.com/file.x');
+  });
+
+  it('should throw error for dot at end of path', () => {
+    expect(() => {
+      inferContentTypeFromImageUrl('https://example.com/path/.');
+    }).toThrow('Invalid image url: https://example.com/path/.');
+  });
+
+  it('should handle malformed URLs that result in no valid extension', () => {
+    // These URLs will be processed by inferFileExtensionFromImageUrl and return empty string
+    const invalidUrls = [
+      'data:image/jpeg;base64,invalid', // No file extension in path
+      'javascript:alert("test")', // No file extension
+      'https://example.com/file', // No extension
+      'https://example.com/file.', // Dot without extension
+      'ftp://example.com/document.pdf', // Valid URL but non-image extension
+    ];
+
+    invalidUrls.forEach((url) => {
+      expect(() => {
+        inferContentTypeFromImageUrl(url);
+      }).toThrow(/Invalid image url:/);
+    });
+  });
+
+  it('should handle all supported image formats consistently', () => {
+    const testCases = [
+      { extension: 'jpg', expected: 'image/jpeg' },
+      { extension: 'jpeg', expected: 'image/jpeg' },
+      { extension: 'png', expected: 'image/png' },
+      { extension: 'webp', expected: 'image/webp' },
+      { extension: 'gif', expected: 'image/gif' },
+      { extension: 'bmp', expected: 'image/bmp' },
+      { extension: 'svg', expected: 'image/svg+xml' },
+      { extension: 'tiff', expected: 'image/tiff' },
+      { extension: 'tif', expected: 'image/tiff' },
+    ];
+
+    testCases.forEach(({ extension, expected }) => {
+      const result = inferContentTypeFromImageUrl(`https://example.com/image.${extension}`);
+      expect(result).toBe(expected);
+    });
+  });
+});
+
+describe('inferFileExtensionFromImageUrl', () => {
+  it('should return jpg extension', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/image.jpg');
+    expect(result).toBe('jpg');
+  });
+
+  it('should return png extension', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/image.png');
+    expect(result).toBe('png');
+  });
+
+  it('should return webp extension', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/image.webp');
+    expect(result).toBe('webp');
+  });
+
+  it('should handle jpeg extension', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/image.jpeg');
+    expect(result).toBe('jpeg');
+  });
+
+  it('should handle gif extension', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/image.gif');
+    expect(result).toBe('gif');
+  });
+
+  it('should handle svg extension', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/image.svg');
+    expect(result).toBe('svg');
+  });
+
+  it('should handle uppercase extensions and convert to lowercase', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/image.PNG');
+    expect(result).toBe('png');
+  });
+
+  it('should handle mixed case extensions', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/image.JpEg');
+    expect(result).toBe('jpeg');
+  });
+
+  it('should handle URLs with query parameters', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/image.jpg?v=123&size=large');
+    expect(result).toBe('jpg');
+  });
+
+  it('should handle URLs with hash fragments', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/image.png#section');
+    expect(result).toBe('png');
+  });
+
+  it('should handle multiple dots in path', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/my.folder/image.test.webp');
+    expect(result).toBe('webp');
+  });
+
+  it('should return empty string when no extension', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/image');
+    expect(result).toBe('');
+  });
+
+  it('should return empty string when only dot without extension', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/image.');
+    expect(result).toBe('');
+  });
+
+  it('should return empty string for non-image extensions', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/document.txt');
+    expect(result).toBe('');
+  });
+
+  it('should return empty string for other format extensions', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com/video.mp4');
+    expect(result).toBe('');
+  });
+
+  it('should handle invalid URLs and return empty string', () => {
+    const result = inferFileExtensionFromImageUrl('invalid-url');
+    expect(result).toBe('');
+  });
+
+  it('should handle empty string URLs and return empty string', () => {
+    const result = inferFileExtensionFromImageUrl('');
+    expect(result).toBe('');
+  });
+
+  it('should handle all supported image extensions', () => {
+    const supportedExtensions = ['webp', 'jpg', 'jpeg', 'png', 'gif', 'bmp', 'svg', 'tiff', 'tif'];
+
+    supportedExtensions.forEach((ext) => {
+      const result = inferFileExtensionFromImageUrl(`https://example.com/image.${ext}`);
+      expect(result).toBe(ext);
+    });
+  });
+
+  it('should handle URLs with port numbers', () => {
+    const result = inferFileExtensionFromImageUrl('https://example.com:8080/image.jpg');
+    expect(result).toBe('jpg');
+  });
+
+  it('should handle subdomain URLs', () => {
+    const result = inferFileExtensionFromImageUrl('https://cdn.example.com/images/photo.webp');
+    expect(result).toBe('webp');
+  });
+
+  it('should handle deep path URLs', () => {
+    const result = inferFileExtensionFromImageUrl(
+      'https://example.com/assets/images/gallery/photo.png',
+    );
+    expect(result).toBe('png');
+  });
+
+  it('should handle encoded URLs', () => {
+    const result = inferFileExtensionFromImageUrl(
+      'https://example.com/images/%E5%9B%BE%E7%89%87.jpg',
+    );
+    expect(result).toBe('jpg');
+  });
+
+  it('should handle relative paths', () => {
+    const result = inferFileExtensionFromImageUrl('generations/images/photo.jpg');
+    expect(result).toBe('jpg');
+  });
+
+  it('should handle relative paths with complex filenames', () => {
+    const result = inferFileExtensionFromImageUrl(
+      'generations/images/2NPfAQAMNxXPi82mzOHog_1056x1136_20250702_110911_raw.png',
+    );
+    expect(result).toBe('png');
+  });
+
+  it('should handle relative paths with query parameters', () => {
+    const result = inferFileExtensionFromImageUrl('images/photo.webp?v=123');
+    expect(result).toBe('webp');
+  });
+
+  it('should handle relative paths with hash fragments', () => {
+    const result = inferFileExtensionFromImageUrl('assets/images/banner.gif#preview');
+    expect(result).toBe('gif');
+  });
+});

package/src/utils/url.ts

@@ -1,8 +1,26 @@
+import mime from 'mime';
+
 /**
  * Build a path string from a path and a hash/search object
- * @param path
- * @param hash
- * @param search
+ *
+ * This function constructs a properly formatted URL path by combining a base path
+ * with optional hash and search parameters. It uses URL constructor for proper
+ * encoding and formatting while removing the temporary base domain.
+ *
+ * @param path - The base path (can be relative, absolute, or include protocol)
+ * @param options - Optional configuration object
+ * @param options.hash - Hash fragment to append (with or without leading #)
+ * @param options.search - Search/query parameters to append (with or without leading ?)
+ * @returns Formatted path string with hash and search parameters
+ *
+ * @example
+ * ```typescript
+ * pathString('/home') // '/home'
+ * pathString('/home', { search: 'id=1&name=test' }) // '/home?id=1&name=test'
+ * pathString('/home', { hash: 'top' }) // '/home#top'
+ * pathString('./home') // '/home'
+ * pathString('https://example.com/path') // 'https://example.com/path'
+ * ```
  */
 export const pathString = (
   path: string,
@@ -14,10 +32,94 @@ export const pathString = (
     search?: string;
   } = {},
 ) => {
+  // Use a temporary base URL for proper URL parsing and formatting
   const tempBase = 'https://a.com';
   const url = new URL(path, tempBase);
 
+  // Add hash fragment if provided
   if (hash) url.hash = hash;
+  // Add search parameters if provided
   if (search) url.search = search;
+
+  // Return the formatted URL without the temporary base
   return url.toString().replace(tempBase, '');
 };
+
+/**
+ * Get file extension from URL
+ *
+ * This function extracts the file extension from a URL's pathname and validates it against
+ * common image formats. It properly handles URLs with query parameters, hash fragments,
+ * relative paths, and various edge cases. Returns empty string for invalid cases.
+ *
+ * @param url - The URL to extract extension from (can be relative, absolute, or include query parameters and hash fragments)
+ * @returns file extension without dot (e.g., 'jpg', 'png', 'webp'), or empty string for invalid cases
+ *
+ * @example
+ * ```typescript
+ * inferFileExtensionFromImageUrl('https://example.com/image.jpg') // 'jpg'
+ * inferFileExtensionFromImageUrl('https://example.com/image.png?v=123') // 'png'
+ * inferFileExtensionFromImageUrl('https://example.com/image.webp#section') // 'webp'
+ * inferFileExtensionFromImageUrl('generations/images/photo.png') // 'png'
+ * inferFileExtensionFromImageUrl('https://example.com/document.txt') // '' (empty string)
+ * inferFileExtensionFromImageUrl('invalid-url') // '' (empty string)
+ * ```
+ */
+export const inferFileExtensionFromImageUrl = (url: string): string => {
+  // Use a temporary base URL for proper URL parsing and formatting (handles relative paths)
+  const tempBase = 'https://a.com';
+  const urlObj = new URL(url, tempBase);
+  const pathname = urlObj.pathname;
+
+  // Find the last dot in the pathname to get the file extension
+  const lastDotIndex = pathname.lastIndexOf('.');
+  if (lastDotIndex === -1) return ''; // No extension found, return empty string
+
+  // Extract extension after the last dot and convert to lowercase
+  const extension = pathname.slice(Math.max(0, lastDotIndex + 1)).toLowerCase();
+
+  // Validate against common image extensions
+  const validImageExtensions = ['webp', 'jpg', 'jpeg', 'png', 'gif', 'bmp', 'svg', 'tiff', 'tif'];
+  if (validImageExtensions.includes(extension)) {
+    return extension;
+  }
+
+  // Default fallback for non-image extensions
+  return '';
+};
+
+/**
+ * Infer content type (MIME type) from an image URL
+ *
+ * This function extracts the file extension from a URL and returns the corresponding MIME type.
+ * It properly handles URLs with query parameters, hash fragments, relative paths, and various edge cases.
+ *
+ * @param url - The image URL to analyze (can be relative, absolute, or include query parameters and hash fragments)
+ * @returns MIME type string (e.g., 'image/jpeg', 'image/png')
+ * @throws {Error} When the URL doesn't contain a valid file extension
+ *
+ * @example
+ * ```typescript
+ * inferContentTypeFromImageUrl('https://example.com/image.jpg') // 'image/jpeg'
+ * inferContentTypeFromImageUrl('https://example.com/image.png?v=123') // 'image/png'
+ * inferContentTypeFromImageUrl('https://example.com/image.webp#section') // 'image/webp'
+ * inferContentTypeFromImageUrl('generations/images/photo.png') // 'image/png'
+ * ```
+ */
+export function inferContentTypeFromImageUrl(url: string) {
+  // Get the file extension using the dedicated function
+  // inferFileExtensionFromImageUrl only returns valid image extensions or empty string
+  const extension = inferFileExtensionFromImageUrl(url);
+
+  // If no valid extension found, throw error
+  if (!extension) {
+    throw new Error(`Invalid image url: ${url}`);
+  }
+
+  // Get MIME type using the mime library
+  // Since extension is guaranteed to be a valid image extension from the whitelist,
+  // mime.getType() will always return a valid image MIME type
+  const mimeType = mime.getType(extension);
+
+  return mimeType!; // Non-null assertion is safe due to whitelist validation
+}

package/{vitest.server.config.ts → vitest.config.server.ts}

@@ -26,5 +26,8 @@ export default defineConfig({
       },
     },
     setupFiles: './tests/setup-db.ts',
+    env: {
+      TEST_SERVER_DB: '1',
+    },
   },
 });

package/.cursor/rules/i18n/i18n-auto-attached.mdc

@@ -1,6 +0,0 @@
----
-description: 
-globs: src/locales/**/*
-alwaysApply: false
----
-read [i18n.mdc](mdc:.cursor/rules/i18n/i18n.mdc)

package/src/features/Conversation/Error/APIKeyForm/index.tsx

@@ -1,105 +0,0 @@
-import { ProviderIcon } from '@lobehub/icons';
-import { Button } from '@lobehub/ui';
-import { memo, useMemo, useState } from 'react';
-import { useTranslation } from 'react-i18next';
-import { Center, Flexbox } from 'react-layout-kit';
-
-import { ModelProvider } from '@/libs/model-runtime';
-import { useChatStore } from '@/store/chat';
-import { GlobalLLMProviderKey } from '@/types/user/settings';
-
-import BedrockForm from './Bedrock';
-import { LoadingContext } from './LoadingContext';
-import ProviderApiKeyForm from './ProviderApiKeyForm';
-
-interface APIKeyFormProps {
-  id: string;
-  provider?: string;
-}
-
-const APIKeyForm = memo<APIKeyFormProps>(({ id, provider }) => {
-  const { t } = useTranslation('error');
-  const [loading, setLoading] = useState(false);
-
-  const [resend, deleteMessage] = useChatStore((s) => [s.regenerateMessage, s.deleteMessage]);
-
-  const apiKeyPlaceholder = useMemo(() => {
-    switch (provider) {
-      case ModelProvider.Anthropic: {
-        return 'sk-ant_*****************************';
-      }
-
-      case ModelProvider.OpenRouter: {
-        return 'sk-or-********************************';
-      }
-
-      case ModelProvider.Perplexity: {
-        return 'pplx-********************************';
-      }
-
-      case ModelProvider.ZhiPu: {
-        return '*********************.*************';
-      }
-
-      case ModelProvider.Groq: {
-        return 'gsk_*****************************';
-      }
-
-      case ModelProvider.DeepSeek: {
-        return 'sk_******************************';
-      }
-
-      case ModelProvider.Qwen: {
-        return 'sk-********************************';
-      }
-
-      case ModelProvider.Github: {
-        return 'ghp_*****************************';
-      }
-
-      default: {
-        return '*********************************';
-      }
-    }
-  }, [provider]);
-
-  return (
-    <LoadingContext value={{ loading, setLoading }}>
-      <Center gap={16} style={{ maxWidth: 300 }}>
-        {provider === ModelProvider.Bedrock ? (
-          <BedrockForm />
-        ) : (
-          <ProviderApiKeyForm
-            apiKeyPlaceholder={apiKeyPlaceholder}
-            avatar={<ProviderIcon provider={provider} size={80} type={'avatar'} />}
-            provider={provider as GlobalLLMProviderKey}
-            showEndpoint={provider === ModelProvider.OpenAI}
-          />
-        )}
-        <Flexbox gap={12} width={'100%'}>
-          <Button
-            block
-            disabled={loading}
-            onClick={() => {
-              resend(id);
-              deleteMessage(id);
-            }}
-            style={{ marginTop: 8 }}
-            type={'primary'}
-          >
-            {t('unlock.confirm')}
-          </Button>
-          <Button
-            onClick={() => {
-              deleteMessage(id);
-            }}
-          >
-            {t('unlock.closeMessage')}
-          </Button>
-        </Flexbox>
-      </Center>
-    </LoadingContext>
-  );
-});
-
-export default APIKeyForm;

package/src/features/Conversation/Error/InvalidAPIKey.tsx

@@ -1,16 +0,0 @@
-import { memo } from 'react';
-
-import APIKeyForm from './APIKeyForm';
-import { ErrorActionContainer } from './style';
-
-interface InvalidAPIKeyProps {
-  id: string;
-  provider?: string;
-}
-const InvalidAPIKey = memo<InvalidAPIKeyProps>(({ id, provider }) => (
-  <ErrorActionContainer>
-    <APIKeyForm id={id} provider={provider} />
-  </ErrorActionContainer>
-));
-
-export default InvalidAPIKey;