@lobehub/chat 1.103.2 → 1.104.1

package/src/server/services/generation/index.ts

@@ -4,12 +4,54 @@ import mime from 'mime';
 import { nanoid } from 'nanoid';
 import sharp from 'sharp';
 
+import { IMAGE_GENERATION_CONFIG } from '@/const/imageGeneration';
 import { LobeChatDatabase } from '@/database/type';
+import { parseDataUri } from '@/libs/model-runtime/utils/uriParser';
 import { FileService } from '@/server/services/file';
+import { calculateThumbnailDimensions } from '@/utils/number';
 import { getYYYYmmddHHMMss } from '@/utils/time';
+import { inferFileExtensionFromImageUrl } from '@/utils/url';
 
 const log = debug('lobe-image:generation-service');
 
+/**
+ * Fetch image buffer and MIME type from URL or base64 data
+ * @param url - Image URL or base64 data URI
+ * @returns Object containing buffer and MIME type
+ */
+export async function fetchImageFromUrl(url: string): Promise<{
+  buffer: Buffer;
+  mimeType: string;
+}> {
+  if (url.startsWith('data:')) {
+    const { base64, mimeType, type } = parseDataUri(url);
+
+    if (type !== 'base64' || !base64 || !mimeType) {
+      throw new Error(`Invalid data URI format: ${url}`);
+    }
+
+    try {
+      const buffer = Buffer.from(base64, 'base64');
+      return { buffer, mimeType };
+    } catch (error) {
+      throw new Error(
+        `Failed to decode base64 data: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  } else {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch image from ${url}: ${response.status} ${response.statusText}`,
+      );
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    const mimeType = response.headers.get('content-type') || 'application/octet-stream';
+    return { buffer, mimeType };
+  }
+}
+
 interface ImageForGeneration {
   buffer: Buffer;
   extension: string;
@@ -40,33 +82,12 @@ export class GenerationService {
   }> {
     log('Starting image transformation for:', url.startsWith('data:') ? 'base64 data' : url);
 
-    // If the url is in base64 format, extract the Buffer directly; otherwise, use fetch to get the Buffer
-    let originalImageBuffer: Buffer;
-    let originalMimeType: string;
-
-    if (url.startsWith('data:')) {
-      log('Processing base64 image data');
-      // Extract the MIME type and base64 data part
-      const [mimeTypePart, base64Data] = url.split(',');
-      originalMimeType = mimeTypePart.split(':')[1].split(';')[0];
-      originalImageBuffer = Buffer.from(base64Data, 'base64');
-    } else {
-      log('Fetching image from URL:', url);
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(
-          `Failed to fetch image from ${url}: ${response.status} ${response.statusText}`,
-        );
-      }
-      const arrayBuffer = await response.arrayBuffer();
-      originalImageBuffer = Buffer.from(arrayBuffer);
-      originalMimeType = response.headers.get('content-type') || 'application/octet-stream';
-      log('Successfully fetched image, buffer size:', originalImageBuffer.length);
-    }
+    // Fetch image buffer and MIME type using utility function
+    const { buffer: originalImageBuffer, mimeType: originalMimeType } =
+      await fetchImageFromUrl(url);
 
     // Calculate hash for original image
     const originalHash = sha256(originalImageBuffer);
-    log('Original image hash calculated:', originalHash);
 
     const sharpInstance = sharp(originalImageBuffer);
     const { format, width, height } = await sharpInstance.metadata();
@@ -76,19 +97,20 @@ export class GenerationService {
       throw new Error(`Invalid image format: ${format}, url: ${url}`);
     }
 
-    const shouldResize = format !== 'webp' || width > 512 || height > 512;
-    const thumbnailWidth = shouldResize
-      ? width > height
-        ? 512
-        : Math.round((width * 512) / height)
-      : width;
-    const thumbnailHeight = shouldResize
-      ? height > width
-        ? 512
-        : Math.round((height * 512) / width)
-      : height;
-
-    log('Thumbnail dimensions calculated:', { shouldResize, thumbnailHeight, thumbnailWidth });
+    const {
+      shouldResize: shouldResizeBySize,
+      thumbnailWidth,
+      thumbnailHeight,
+    } = calculateThumbnailDimensions(width, height);
+    const shouldResize = shouldResizeBySize || format !== 'webp';
+
+    log('Thumbnail processing decision:', {
+      format,
+      shouldResize,
+      shouldResizeBySize,
+      thumbnailHeight,
+      thumbnailWidth,
+    });
 
     const thumbnailBuffer = shouldResize
       ? await sharpInstance.resize(thumbnailWidth, thumbnailHeight).webp().toBuffer()
@@ -96,11 +118,10 @@ export class GenerationService {
 
     // Calculate hash for thumbnail
     const thumbnailHash = sha256(thumbnailBuffer);
-    log('Thumbnail image hash calculated:', thumbnailHash);
 
     log('Image transformation completed successfully');
 
-    // Determine extension without fallback
+    // Determine extension using url utility
     let extension: string;
     if (url.startsWith('data:')) {
       const mimeExtension = mime.getExtension(originalMimeType);
@@ -109,11 +130,10 @@ export class GenerationService {
       }
       extension = mimeExtension;
     } else {
-      const urlExtension = url.split('.').pop();
-      if (!urlExtension) {
+      extension = inferFileExtensionFromImageUrl(url);
+      if (!extension) {
         throw new Error(`Unable to determine file extension from URL: ${url}`);
       }
-      extension = urlExtension;
     }
 
     return {
@@ -144,9 +164,8 @@ export class GenerationService {
     const generationImagesFolder = 'generations/images';
     const uuid = nanoid();
     const dateTime = getYYYYmmddHHMMss(new Date());
-    const pathPrefix = `${generationImagesFolder}/${uuid}_${image.width}x${image.height}_${dateTime}`;
-    const imageKey = `${pathPrefix}_raw.${image.extension}`;
-    const thumbnailKey = `${pathPrefix}_thumb.${thumbnail.extension}`;
+    const imageKey = `${generationImagesFolder}/${uuid}_${image.width}x${image.height}_${dateTime}_raw.${image.extension}`;
+    const thumbnailKey = `${generationImagesFolder}/${uuid}_${thumbnail.width}x${thumbnail.height}_${dateTime}_thumb.${thumbnail.extension}`;
 
     log('Generated paths:', { imagePath: imageKey, thumbnailPath: thumbnailKey });
 
@@ -189,37 +208,39 @@ export class GenerationService {
   }
 
   /**
-   * Create a 256x256 cover image from a given URL and upload
+   * Create a cover image from a given URL and upload
    * @param coverUrl - The source image URL (can be base64 or HTTP URL)
    * @returns The key of the uploaded cover image
    */
   async createCoverFromUrl(coverUrl: string): Promise<string> {
     log('Creating cover image from URL:', coverUrl.startsWith('data:') ? 'base64 data' : coverUrl);
 
-    // Download the original image
-    let originalImageBuffer: Buffer;
-    if (coverUrl.startsWith('data:')) {
-      log('Processing base64 cover image data');
-      // Extract base64 data part
-      const [, base64Data] = coverUrl.split(',');
-      originalImageBuffer = Buffer.from(base64Data, 'base64');
-    } else {
-      log('Fetching cover image from URL:', coverUrl);
-      const response = await fetch(coverUrl);
-      if (!response.ok) {
-        throw new Error(
-          `Failed to fetch cover image from ${coverUrl}: ${response.status} ${response.statusText}`,
-        );
-      }
-      const arrayBuffer = await response.arrayBuffer();
-      originalImageBuffer = Buffer.from(arrayBuffer);
-      log('Successfully fetched cover image, buffer size:', originalImageBuffer.length);
+    // Fetch image buffer using utility function
+    const { buffer: originalImageBuffer } = await fetchImageFromUrl(coverUrl);
+
+    // Get image metadata to calculate proper cover dimensions
+    const sharpInstance = sharp(originalImageBuffer);
+    const { width, height } = await sharpInstance.metadata();
+
+    if (!width || !height) {
+      throw new Error('Invalid image format for cover creation');
     }
 
-    // Process image to 256x256 cover with webp format
-    log('Processing cover image to 256x256 webp format');
-    const coverBuffer = await sharp(originalImageBuffer)
-      .resize(256, 256, { fit: 'cover', position: 'center' })
+    // Calculate cover dimensions maintaining aspect ratio with configurable max size
+    const { thumbnailWidth, thumbnailHeight } = calculateThumbnailDimensions(
+      width,
+      height,
+      IMAGE_GENERATION_CONFIG.COVER_MAX_SIZE,
+    );
+
+    log('Processing cover image with dimensions:', {
+      cover: { height: thumbnailHeight, width: thumbnailWidth },
+      original: { height, width },
+    });
+
+    const coverBuffer = await sharpInstance
+      .resize(thumbnailWidth, thumbnailHeight)
+      .webp()
       .toBuffer();
 
     log('Cover image processed, final size:', coverBuffer.length);
@@ -228,7 +249,7 @@ export class GenerationService {
     const coverFolder = 'generations/covers';
     const uuid = nanoid();
     const dateTime = getYYYYmmddHHMMss(new Date());
-    const coverKey = `${coverFolder}/${uuid}_cover_${dateTime}.webp`;
+    const coverKey = `${coverFolder}/${uuid}_${thumbnailWidth}x${thumbnailHeight}_${dateTime}_cover.webp`;
 
     log('Uploading cover image:', coverKey);
     const result = await this.fileService.uploadMedia(coverKey, coverBuffer);

package/src/services/electron/settings.ts

@@ -1,4 +1,8 @@
-import { NetworkProxySettings, dispatch } from '@lobechat/electron-client-ipc';
+import {
+  NetworkProxySettings,
+  ShortcutUpdateResult,
+  dispatch,
+} from '@lobechat/electron-client-ipc';
 
 class DesktopSettingsService {
   /**
@@ -15,6 +19,20 @@ class DesktopSettingsService {
     return dispatch('setProxySettings', data);
   };
 
+  /**
+   * 获取桌面热键配置
+   */
+  getDesktopHotkeys = async () => {
+    return dispatch('getShortcutsConfig');
+  };
+
+  /**
+   * 更新桌面热键配置
+   */
+  updateDesktopHotkey = async (id: string, accelerator: string): Promise<ShortcutUpdateResult> => {
+    return dispatch('updateShortcutConfig', { accelerator, id });
+  };
+
   /**
    * 测试代理连接
    */

package/src/store/electron/actions/settings.ts

@@ -1,4 +1,4 @@
-import { NetworkProxySettings } from '@lobechat/electron-client-ipc';
+import { NetworkProxySettings, ShortcutUpdateResult } from '@lobechat/electron-client-ipc';
 import isEqual from 'fast-deep-equal';
 import useSWR, { SWRResponse, mutate } from 'swr';
 import type { StateCreator } from 'zustand/vanilla';
@@ -11,12 +11,16 @@ import type { ElectronStore } from '../store';
  * 设置操作
  */
 export interface ElectronSettingsAction {
+  refreshDesktopHotkeys: () => Promise<void>;
   refreshProxySettings: () => Promise<void>;
   setProxySettings: (params: Partial<NetworkProxySettings>) => Promise<void>;
+  updateDesktopHotkey: (id: string, accelerator: string) => Promise<ShortcutUpdateResult>;
+  useFetchDesktopHotkeys: () => SWRResponse;
   useGetProxySettings: () => SWRResponse;
 }
 
 const ELECTRON_PROXY_SETTINGS_KEY = 'electron:getProxySettings';
+const ELECTRON_DESKTOP_HOTKEYS_KEY = 'electron:getDesktopHotkeys';
 
 export const settingsSlice: StateCreator<
   ElectronStore,
@@ -24,6 +28,10 @@ export const settingsSlice: StateCreator<
   [],
   ElectronSettingsAction
 > = (set, get) => ({
+  refreshDesktopHotkeys: async () => {
+    await mutate(ELECTRON_DESKTOP_HOTKEYS_KEY);
+  },
+
   refreshProxySettings: async () => {
     await mutate(ELECTRON_PROXY_SETTINGS_KEY);
   },
@@ -40,6 +48,39 @@ export const settingsSlice: StateCreator<
     }
   },
 
+  updateDesktopHotkey: async (id, accelerator) => {
+    try {
+      // 更新热键配置
+      const result = await desktopSettingsService.updateDesktopHotkey(id, accelerator);
+
+      // 如果更新成功，刷新状态
+      if (result.success) {
+        await get().refreshDesktopHotkeys();
+      }
+
+      return result;
+    } catch (error) {
+      console.error('桌面热键更新失败:', error);
+      return {
+        errorType: 'UNKNOWN' as const,
+        success: false,
+      };
+    }
+  },
+
+  useFetchDesktopHotkeys: () =>
+    useSWR<Record<string, string>>(
+      ELECTRON_DESKTOP_HOTKEYS_KEY,
+      async () => desktopSettingsService.getDesktopHotkeys(),
+      {
+        onSuccess: (data) => {
+          if (!isEqual(data, get().desktopHotkeys)) {
+            set({ desktopHotkeys: data, isDesktopHotkeysInit: true });
+          }
+        },
+      },
+    ),
+
   useGetProxySettings: () =>
     useSWR<NetworkProxySettings>(
       ELECTRON_PROXY_SETTINGS_KEY,

package/src/store/electron/initialState.ts

@@ -1,4 +1,8 @@
-import { DataSyncConfig, ElectronAppState, NetworkProxySettings } from '@lobechat/electron-client-ipc';
+import {
+  DataSyncConfig,
+  ElectronAppState,
+  NetworkProxySettings,
+} from '@lobechat/electron-client-ipc';
 
 export type RemoteServerError = 'CONFIG_ERROR' | 'AUTH_ERROR' | 'DISCONNECT_ERROR';
 
@@ -14,8 +18,10 @@ export const defaultProxySettings: NetworkProxySettings = {
 export interface ElectronState {
   appState: ElectronAppState;
   dataSyncConfig: DataSyncConfig;
+  desktopHotkeys: Record<string, string>;
   isAppStateInit?: boolean;
   isConnectingServer?: boolean;
+  isDesktopHotkeysInit: boolean;
   isInitRemoteServerConfig: boolean;
   isSyncActive?: boolean;
   proxySettings: NetworkProxySettings;
@@ -25,8 +31,10 @@ export interface ElectronState {
 export const initialState: ElectronState = {
   appState: {},
   dataSyncConfig: { storageMode: 'local' },
+  desktopHotkeys: {},
   isAppStateInit: false,
   isConnectingServer: false,
+  isDesktopHotkeysInit: false,
   isInitRemoteServerConfig: false,
   isSyncActive: false,
   proxySettings: defaultProxySettings,

package/src/store/electron/selectors/__tests__/desktopState.test.ts

@@ -1,14 +1,14 @@
 import { describe, expect, it } from 'vitest';
 
-import { ElectronState, defaultProxySettings } from '@/store/electron/initialState';
+import { ElectronState, defaultProxySettings, initialState } from '@/store/electron/initialState';
+import { merge } from '@/utils/merge';
 
 import { desktopStateSelectors } from '../desktopState';
 
 describe('desktopStateSelectors', () => {
   describe('usePath', () => {
     it('should return userPath from appState', () => {
-      const state: ElectronState = {
-        isAppStateInit: false,
+      const state: ElectronState = merge(initialState, {
         appState: {
           userPath: {
             desktop: '/test/desktop',
@@ -21,12 +21,7 @@ describe('desktopStateSelectors', () => {
             videos: '/test/videos',
           },
         },
-        dataSyncConfig: {
-          storageMode: 'local',
-        },
-        isInitRemoteServerConfig: false,
-        proxySettings: defaultProxySettings,
-      };
+      });
 
       expect(desktopStateSelectors.usePath(state)).toEqual({
         desktop: '/test/desktop',
@@ -41,15 +36,9 @@ describe('desktopStateSelectors', () => {
     });
 
     it('should handle undefined userPath', () => {
-      const state: ElectronState = {
+      const state: ElectronState = merge(initialState, {
         appState: {},
-        isAppStateInit: false,
-        dataSyncConfig: {
-          storageMode: 'local',
-        },
-        isInitRemoteServerConfig: false,
-        proxySettings: defaultProxySettings,
-      };
+      });
 
       expect(desktopStateSelectors.usePath(state)).toBeUndefined();
     });

package/src/store/electron/selectors/hotkey.ts

@@ -0,0 +1,11 @@
+import { DEFAULT_DESKTOP_HOTKEY_CONFIG } from '@/const/desktop';
+import { ElectronState } from '@/store/electron/initialState';
+import { merge } from '@/utils/merge';
+
+const hotkeys = (s: ElectronState) => merge(DEFAULT_DESKTOP_HOTKEY_CONFIG, s.desktopHotkeys);
+const isHotkeysInit = (s: ElectronState) => s.isDesktopHotkeysInit;
+
+export const desktopHotkeysSelectors = {
+  hotkeys,
+  isHotkeysInit,
+};

package/src/store/electron/selectors/index.ts

@@ -1,2 +1,3 @@
 export * from './desktopState';
+export * from './hotkey';
 export * from './sync';

package/src/types/hotkey.ts

@@ -62,7 +62,6 @@ export const HotkeyEnum = {
   EditMessage: 'editMessage',
   OpenChatSettings: 'openChatSettings',
   OpenHotkeyHelper: 'openHotkeyHelper',
-  OpenSettings: 'openSettings',
   RegenerateMessage: 'regenerateMessage',
   SaveTopic: 'saveTopic',
   Search: 'search',
@@ -96,8 +95,6 @@ export interface HotkeyItem {
   // 快捷键分组用于展示
   group: HotkeyGroupId;
   id: HotkeyId;
-  isDesktop?: boolean;
-  // 是否是桌面端专用的快捷键
   keys: string;
   // 是否为不可编辑的快捷键
   nonEditable?: boolean;
@@ -105,7 +102,24 @@ export interface HotkeyItem {
   scopes?: HotkeyScopeId[];
 }
 
-export type HotkeyRegistration = HotkeyItem[];
+// ================== Desktop ================== //
+
+export const DesktopHotkeyEnum = {
+  OpenSettings: 'openSettings',
+  ShowApp: 'showApp',
+};
+
+export type DesktopHotkeyId = (typeof DesktopHotkeyEnum)[keyof typeof DesktopHotkeyEnum];
+
+export interface DesktopHotkeyItem {
+  id: DesktopHotkeyId;
+
+  keys: string;
+  // 是否为不可编辑的快捷键
+  nonEditable?: boolean;
+}
+
+export type DesktopHotkeyConfig = Record<DesktopHotkeyId, string>;
 
 export type HotkeyI18nTranslations = Record<
   HotkeyId,

package/src/utils/number.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
 
-import { MAX_SEED, generateUniqueSeeds } from './number';
+import { MAX_SEED, calculateThumbnailDimensions, generateUniqueSeeds } from './number';
 
 describe('number utilities', () => {
   describe('MAX_SEED constant', () => {
@@ -102,4 +102,104 @@ describe('number utilities', () => {
       vi.useRealTimers();
     });
   });
+
+  describe('calculateThumbnailDimensions', () => {
+    it('should not resize when both dimensions are within max size', () => {
+      const result = calculateThumbnailDimensions(400, 300);
+
+      expect(result).toEqual({
+        shouldResize: false,
+        thumbnailWidth: 400,
+        thumbnailHeight: 300,
+      });
+    });
+
+    it('should not resize when dimensions equal max size', () => {
+      const result = calculateThumbnailDimensions(512, 512);
+
+      expect(result).toEqual({
+        shouldResize: false,
+        thumbnailWidth: 512,
+        thumbnailHeight: 512,
+      });
+    });
+
+    it('should resize when width exceeds max size (landscape)', () => {
+      const result = calculateThumbnailDimensions(1024, 768);
+
+      expect(result).toEqual({
+        shouldResize: true,
+        thumbnailWidth: 512,
+        thumbnailHeight: 384, // Math.round((768 * 512) / 1024)
+      });
+    });
+
+    it('should resize when height exceeds max size (portrait)', () => {
+      const result = calculateThumbnailDimensions(768, 1024);
+
+      expect(result).toEqual({
+        shouldResize: true,
+        thumbnailWidth: 384, // Math.round((768 * 512) / 1024)
+        thumbnailHeight: 512,
+      });
+    });
+
+    it('should resize square images correctly', () => {
+      const result = calculateThumbnailDimensions(1024, 1024);
+
+      expect(result).toEqual({
+        shouldResize: true,
+        thumbnailWidth: 512,
+        thumbnailHeight: 512,
+      });
+    });
+
+    it('should handle very large images', () => {
+      const result = calculateThumbnailDimensions(2048, 1536);
+
+      expect(result).toEqual({
+        shouldResize: true,
+        thumbnailWidth: 512,
+        thumbnailHeight: 384, // Math.round((1536 * 512) / 2048)
+      });
+    });
+
+    it('should handle very tall images', () => {
+      const result = calculateThumbnailDimensions(800, 2400);
+
+      expect(result).toEqual({
+        shouldResize: true,
+        thumbnailWidth: 171, // Math.round((800 * 512) / 2400)
+        thumbnailHeight: 512,
+      });
+    });
+
+    it('should work with custom max size', () => {
+      const result = calculateThumbnailDimensions(1000, 800, 256);
+
+      expect(result).toEqual({
+        shouldResize: true,
+        thumbnailWidth: 256,
+        thumbnailHeight: 205, // Math.round((800 * 256) / 1000)
+      });
+    });
+
+    it('should handle edge case with very small dimensions', () => {
+      const result = calculateThumbnailDimensions(50, 100);
+
+      expect(result).toEqual({
+        shouldResize: false,
+        thumbnailWidth: 50,
+        thumbnailHeight: 100,
+      });
+    });
+
+    it('should maintain aspect ratio correctly', () => {
+      const result = calculateThumbnailDimensions(1600, 900);
+      const originalRatio = 1600 / 900;
+      const thumbnailRatio = result.thumbnailWidth / result.thumbnailHeight;
+
+      expect(Math.abs(originalRatio - thumbnailRatio)).toBeLessThan(0.01);
+    });
+  });
 });

package/src/utils/number.ts

@@ -1,5 +1,7 @@
 import prand from 'pure-rand';
 
+import { IMAGE_GENERATION_CONFIG } from '@/const/imageGeneration';
+
 export const MAX_SEED = 2 ** 31 - 1;
 export function generateUniqueSeeds(seedCount: number): number[] {
   // Use current timestamp as the initial seed
@@ -23,3 +25,43 @@ export function generateUniqueSeeds(seedCount: number): number[] {
 
   return Array.from(seeds);
 }
+
+/**
+ * Calculate thumbnail dimensions
+ * Generate thumbnail with configurable max edge size
+ */
+export function calculateThumbnailDimensions(
+  originalWidth: number,
+  originalHeight: number,
+  maxSize: number = IMAGE_GENERATION_CONFIG.THUMBNAIL_MAX_SIZE,
+): {
+  shouldResize: boolean;
+  thumbnailHeight: number;
+  thumbnailWidth: number;
+} {
+  const shouldResize = originalWidth > maxSize || originalHeight > maxSize;
+
+  if (!shouldResize) {
+    return {
+      shouldResize: false,
+      thumbnailHeight: originalHeight,
+      thumbnailWidth: originalWidth,
+    };
+  }
+
+  const thumbnailWidth =
+    originalWidth > originalHeight
+      ? maxSize
+      : Math.round((originalWidth * maxSize) / originalHeight);
+
+  const thumbnailHeight =
+    originalHeight > originalWidth
+      ? maxSize
+      : Math.round((originalHeight * maxSize) / originalWidth);
+
+  return {
+    shouldResize: true,
+    thumbnailHeight,
+    thumbnailWidth,
+  };
+}