@lobehub/lobehub 2.0.0-next.258 → 2.0.0-next.259

package/apps/desktop/src/main/controllers/__tests__/SystemCtr.test.ts

@@ -7,13 +7,20 @@ import { IpcHandler } from '@/utils/ipc/base';
 
 import SystemController from '../SystemCtr';
 
-const { ipcHandlers, ipcMainHandleMock, readdirSyncMock } = vi.hoisted(() => {
+const { ipcHandlers, ipcMainHandleMock, permissionsMock } = vi.hoisted(() => {
   const handlers = new Map<string, (event: any, ...args: any[]) => any>();
   const handle = vi.fn((channel: string, handler: any) => {
     handlers.set(channel, handler);
   });
-  const readdirSync = vi.fn();
-  return { ipcHandlers: handlers, ipcMainHandleMock: handle, readdirSyncMock: readdirSync };
+  const permissions = {
+    askForAccessibilityAccess: vi.fn(() => undefined),
+    askForCameraAccess: vi.fn(() => Promise.resolve('authorized')),
+    askForFullDiskAccess: vi.fn(() => undefined),
+    askForMicrophoneAccess: vi.fn(() => Promise.resolve('authorized')),
+    askForScreenCaptureAccess: vi.fn(() => undefined),
+    getAuthStatus: vi.fn(() => 'authorized'),
+  };
+  return { ipcHandlers: handlers, ipcMainHandleMock: handle, permissionsMock: permissions };
 });
 
 const invokeIpc = async <T = any>(
@@ -80,31 +87,8 @@ vi.mock('electron-is', () => ({
   macOS: vi.fn(() => true),
 }));
 
-// Mock node:fs for Full Disk Access check
-vi.mock('node:fs', () => ({
-  default: {
-    readdirSync: readdirSyncMock,
-  },
-  readdirSync: readdirSyncMock,
-}));
-
-// Mock node:os for homedir and release
-vi.mock('node:os', () => ({
-  default: {
-    homedir: vi.fn(() => '/Users/testuser'),
-    release: vi.fn(() => '23.0.0'), // Darwin 23 = macOS 14 (Sonoma)
-  },
-  homedir: vi.fn(() => '/Users/testuser'),
-  release: vi.fn(() => '23.0.0'),
-}));
-
-// Mock node:path
-vi.mock('node:path', () => ({
-  default: {
-    join: vi.fn((...args: string[]) => args.join('/')),
-  },
-  join: vi.fn((...args: string[]) => args.join('/')),
-}));
+// Mock node-mac-permissions
+vi.mock('node-mac-permissions', () => permissionsMock);
 
 // Mock browserManager
 const mockBrowserManager = {
@@ -173,22 +157,23 @@ describe('SystemController', () => {
 
   describe('accessibility', () => {
     it('should request accessibility access on macOS', async () => {
-      const { systemPreferences } = await import('electron');
+      permissionsMock.getAuthStatus.mockReturnValue('authorized');
 
-      await invokeIpc('system.requestAccessibilityAccess');
+      const result = await invokeIpc('system.requestAccessibilityAccess');
 
-      expect(systemPreferences.isTrustedAccessibilityClient).toHaveBeenCalledWith(true);
+      expect(permissionsMock.askForAccessibilityAccess).toHaveBeenCalled();
+      expect(permissionsMock.getAuthStatus).toHaveBeenCalledWith('accessibility');
+      expect(result).toBe(true);
     });
 
     it('should return true on non-macOS when requesting accessibility access', async () => {
       const { macOS } = await import('electron-is');
-      const { systemPreferences } = await import('electron');
       vi.mocked(macOS).mockReturnValue(false);
 
       const result = await invokeIpc('system.requestAccessibilityAccess');
 
       expect(result).toBe(true);
-      expect(systemPreferences.isTrustedAccessibilityClient).not.toHaveBeenCalled();
+      expect(permissionsMock.askForAccessibilityAccess).not.toHaveBeenCalled();
 
       // Reset
       vi.mocked(macOS).mockReturnValue(true);
@@ -197,57 +182,55 @@ describe('SystemController', () => {
 
   describe('microphone access', () => {
     it('should ask for microphone access when status is not-determined', async () => {
-      const { systemPreferences } = await import('electron');
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('not-determined');
+      permissionsMock.getAuthStatus.mockReturnValue('not determined');
+      permissionsMock.askForMicrophoneAccess.mockResolvedValue('authorized');
 
-      await invokeIpc('system.requestMicrophoneAccess');
+      const result = await invokeIpc('system.requestMicrophoneAccess');
 
-      expect(systemPreferences.getMediaAccessStatus).toHaveBeenCalledWith('microphone');
-      expect(systemPreferences.askForMediaAccess).toHaveBeenCalledWith('microphone');
+      expect(permissionsMock.getAuthStatus).toHaveBeenCalledWith('microphone');
+      expect(permissionsMock.askForMicrophoneAccess).toHaveBeenCalled();
+      expect(result).toBe(true);
 
       // Reset
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('not-determined');
+      permissionsMock.getAuthStatus.mockReturnValue('authorized');
     });
 
     it('should return true immediately if microphone access is already granted', async () => {
-      const { shell, systemPreferences } = await import('electron');
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('granted');
+      const { shell } = await import('electron');
+      permissionsMock.getAuthStatus.mockReturnValue('authorized');
 
       const result = await invokeIpc('system.requestMicrophoneAccess');
 
       expect(result).toBe(true);
-      expect(systemPreferences.askForMediaAccess).not.toHaveBeenCalled();
+      expect(permissionsMock.askForMicrophoneAccess).not.toHaveBeenCalled();
       expect(shell.openExternal).not.toHaveBeenCalled();
-
-      // Reset
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('not-determined');
     });
 
     it('should open System Settings if microphone access is denied', async () => {
-      const { shell, systemPreferences } = await import('electron');
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('denied');
+      const { shell } = await import('electron');
+      permissionsMock.getAuthStatus.mockReturnValue('denied');
 
       const result = await invokeIpc('system.requestMicrophoneAccess');
 
       expect(result).toBe(false);
-      expect(systemPreferences.askForMediaAccess).not.toHaveBeenCalled();
+      expect(permissionsMock.askForMicrophoneAccess).not.toHaveBeenCalled();
       expect(shell.openExternal).toHaveBeenCalledWith(
         'x-apple.systempreferences:com.apple.preference.security?Privacy_Microphone',
       );
 
       // Reset
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('not-determined');
+      permissionsMock.getAuthStatus.mockReturnValue('authorized');
     });
 
     it('should return true on non-macOS', async () => {
       const { macOS } = await import('electron-is');
-      const { shell, systemPreferences } = await import('electron');
+      const { shell } = await import('electron');
       vi.mocked(macOS).mockReturnValue(false);
 
       const result = await invokeIpc('system.requestMicrophoneAccess');
 
       expect(result).toBe(true);
-      expect(systemPreferences.getMediaAccessStatus).not.toHaveBeenCalled();
+      expect(permissionsMock.getAuthStatus).not.toHaveBeenCalled();
       expect(shell.openExternal).not.toHaveBeenCalled();
 
       // Reset
@@ -256,48 +239,33 @@ describe('SystemController', () => {
   });
 
   describe('screen recording', () => {
-    it('should use desktopCapturer and getDisplayMedia to trigger TCC and open System Settings on macOS', async () => {
-      const { desktopCapturer, shell, systemPreferences } = await import('electron');
+    it('should request screen capture access on macOS', async () => {
+      permissionsMock.getAuthStatus.mockReturnValue('not determined');
 
       const result = await invokeIpc('system.requestScreenAccess');
 
-      expect(systemPreferences.getMediaAccessStatus).toHaveBeenCalledWith('screen');
-      expect(desktopCapturer.getSources).toHaveBeenCalledWith({
-        fetchWindowIcons: true,
-        thumbnailSize: { height: 144, width: 256 },
-        types: ['screen', 'window'],
-      });
-      expect(mockBrowserManager.getMainWindow).toHaveBeenCalled();
-      expect(shell.openExternal).toHaveBeenCalledWith(
-        'x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture',
-      );
+      expect(permissionsMock.getAuthStatus).toHaveBeenCalledWith('screen');
+      expect(permissionsMock.askForScreenCaptureAccess).toHaveBeenCalled();
       expect(typeof result).toBe('boolean');
     });
 
     it('should return true immediately if screen access is already granted', async () => {
-      const { desktopCapturer, shell, systemPreferences } = await import('electron');
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('granted');
+      permissionsMock.getAuthStatus.mockReturnValue('authorized');
 
       const result = await invokeIpc('system.requestScreenAccess');
 
       expect(result).toBe(true);
-      expect(desktopCapturer.getSources).not.toHaveBeenCalled();
-      expect(shell.openExternal).not.toHaveBeenCalled();
-
-      // Reset
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('not-determined');
+      expect(permissionsMock.askForScreenCaptureAccess).not.toHaveBeenCalled();
     });
 
     it('should return true on non-macOS and not open settings', async () => {
       const { macOS } = await import('electron-is');
-      const { desktopCapturer, shell } = await import('electron');
       vi.mocked(macOS).mockReturnValue(false);
 
       const result = await invokeIpc('system.requestScreenAccess');
 
       expect(result).toBe(true);
-      expect(desktopCapturer.getSources).not.toHaveBeenCalled();
-      expect(shell.openExternal).not.toHaveBeenCalled();
+      expect(permissionsMock.askForScreenCaptureAccess).not.toHaveBeenCalled();
 
       // Reset
       vi.mocked(macOS).mockReturnValue(true);
@@ -305,26 +273,24 @@ describe('SystemController', () => {
   });
 
   describe('full disk access', () => {
-    it('should return true when Full Disk Access is granted (can read protected directory)', async () => {
-      readdirSyncMock.mockReturnValue(['file1', 'file2']);
+    it('should return true when Full Disk Access is granted', async () => {
+      permissionsMock.getAuthStatus.mockReturnValue('authorized');
 
       const result = await invokeIpc('system.getFullDiskAccessStatus');
 
       expect(result).toBe(true);
-      // On macOS 14 (Darwin 23), should check com.apple.stocks
-      expect(readdirSyncMock).toHaveBeenCalledWith(
-        '/Users/testuser/Library/Containers/com.apple.stocks',
-      );
+      expect(permissionsMock.getAuthStatus).toHaveBeenCalledWith('full-disk-access');
     });
 
-    it('should return false when Full Disk Access is not granted (cannot read protected directory)', async () => {
-      readdirSyncMock.mockImplementation(() => {
-        throw new Error('EPERM: operation not permitted');
-      });
+    it('should return false when Full Disk Access is not granted', async () => {
+      permissionsMock.getAuthStatus.mockReturnValue('denied');
 
       const result = await invokeIpc('system.getFullDiskAccessStatus');
 
       expect(result).toBe(false);
+
+      // Reset
+      permissionsMock.getAuthStatus.mockReturnValue('authorized');
     });
 
     it('should return true on non-macOS', async () => {
@@ -370,7 +336,7 @@ describe('SystemController', () => {
     });
 
     it('should return granted if Full Disk Access is already granted', async () => {
-      readdirSyncMock.mockReturnValue(['file1', 'file2']);
+      permissionsMock.getAuthStatus.mockReturnValue('authorized');
 
       const result = await invokeIpc('system.promptFullDiskAccessIfNotGranted');
 
@@ -379,9 +345,7 @@ describe('SystemController', () => {
 
     it('should show dialog and open settings when user clicks Open Settings', async () => {
       const { dialog, shell } = await import('electron');
-      readdirSyncMock.mockImplementation(() => {
-        throw new Error('EPERM: operation not permitted');
-      });
+      permissionsMock.getAuthStatus.mockReturnValue('denied');
       vi.mocked(dialog.showMessageBox).mockResolvedValue({ response: 0 } as any);
 
       const result = await invokeIpc('system.promptFullDiskAccessIfNotGranted');
@@ -389,13 +353,14 @@ describe('SystemController', () => {
       expect(result).toBe('opened_settings');
       expect(dialog.showMessageBox).toHaveBeenCalled();
       expect(shell.openExternal).toHaveBeenCalled();
+
+      // Reset
+      permissionsMock.getAuthStatus.mockReturnValue('authorized');
     });
 
     it('should return skipped when user clicks Later', async () => {
       const { dialog, shell } = await import('electron');
-      readdirSyncMock.mockImplementation(() => {
-        throw new Error('EPERM: operation not permitted');
-      });
+      permissionsMock.getAuthStatus.mockReturnValue('denied');
       vi.mocked(dialog.showMessageBox).mockResolvedValue({ response: 1 } as any);
       vi.mocked(shell.openExternal).mockClear();
 
@@ -405,6 +370,9 @@ describe('SystemController', () => {
       expect(dialog.showMessageBox).toHaveBeenCalled();
       // Should not open settings when user skips
       expect(shell.openExternal).not.toHaveBeenCalled();
+
+      // Reset
+      permissionsMock.getAuthStatus.mockReturnValue('authorized');
     });
   });
 

package/apps/desktop/src/main/utils/permissions.ts

@@ -0,0 +1,307 @@
+/**
+ * Unified macOS Permission Management using node-mac-permissions
+ * @see https://github.com/codebytere/node-mac-permissions
+ */
+import { shell } from 'electron';
+import { macOS } from 'electron-is';
+import {
+  askForAccessibilityAccess,
+  askForCameraAccess,
+  askForFullDiskAccess,
+  askForMicrophoneAccess,
+  askForScreenCaptureAccess,
+  getAuthStatus,
+  type AuthType,
+  type PermissionType,
+} from 'node-mac-permissions';
+
+import { createLogger } from './logger';
+
+const logger = createLogger('utils:permissions');
+
+/**
+ * Permission status mapping between node-mac-permissions and our internal representation
+ */
+export type PermissionStatus =
+  | 'authorized'
+  | 'denied'
+  | 'not-determined'
+  | 'restricted'
+  | 'granted'; // alias for authorized
+
+/**
+ * Normalize permission status to a consistent format
+ */
+function normalizeStatus(status: PermissionType | 'not determined'): PermissionStatus {
+  if (status === 'not determined') return 'not-determined';
+  if (status === 'authorized') return 'granted';
+  return status;
+}
+
+/**
+ * Get the authorization status for a specific permission type
+ */
+export function getPermissionStatus(type: AuthType): PermissionStatus {
+  if (!macOS()) {
+    logger.debug(`[Permission] Not macOS, returning granted for ${type}`);
+    return 'granted';
+  }
+
+  const status = getAuthStatus(type);
+  const normalized = normalizeStatus(status);
+  logger.info(`[Permission] ${type} status: ${normalized}`);
+  return normalized;
+}
+
+/**
+ * Check if Accessibility permission is granted
+ */
+export function getAccessibilityStatus(): PermissionStatus {
+  return getPermissionStatus('accessibility');
+}
+
+/**
+ * Request Accessibility permission
+ * Opens System Preferences to the Accessibility pane
+ */
+export function requestAccessibilityAccess(): boolean {
+  if (!macOS()) {
+    logger.info('[Accessibility] Not macOS, returning true');
+    return true;
+  }
+
+  logger.info('[Accessibility] Requesting accessibility access...');
+  askForAccessibilityAccess();
+
+  // Check the status after requesting
+  const status = getPermissionStatus('accessibility');
+  return status === 'granted';
+}
+
+/**
+ * Check if Microphone permission is granted
+ */
+export function getMicrophoneStatus(): PermissionStatus {
+  return getPermissionStatus('microphone');
+}
+
+/**
+ * Request Microphone permission
+ * Shows the system permission dialog if not determined
+ */
+export async function requestMicrophoneAccess(): Promise<boolean> {
+  if (!macOS()) {
+    logger.info('[Microphone] Not macOS, returning true');
+    return true;
+  }
+
+  const currentStatus = getPermissionStatus('microphone');
+  logger.info(`[Microphone] Current status: ${currentStatus}`);
+
+  if (currentStatus === 'granted') {
+    logger.info('[Microphone] Already granted');
+    return true;
+  }
+
+  if (currentStatus === 'not-determined') {
+    logger.info('[Microphone] Status is not-determined, requesting access...');
+    try {
+      const result = await askForMicrophoneAccess();
+      logger.info(`[Microphone] askForMicrophoneAccess result: ${result}`);
+      return result === 'authorized';
+    } catch (error) {
+      logger.error('[Microphone] askForMicrophoneAccess failed:', error);
+      return false;
+    }
+  }
+
+  // If denied or restricted, open System Settings for manual enable
+  logger.info(`[Microphone] Status is ${currentStatus}, opening System Settings...`);
+  await shell.openExternal(
+    'x-apple.systempreferences:com.apple.preference.security?Privacy_Microphone',
+  );
+  return false;
+}
+
+/**
+ * Check if Camera permission is granted
+ */
+export function getCameraStatus(): PermissionStatus {
+  return getPermissionStatus('camera');
+}
+
+/**
+ * Request Camera permission
+ * Shows the system permission dialog if not determined
+ */
+export async function requestCameraAccess(): Promise<boolean> {
+  if (!macOS()) {
+    logger.info('[Camera] Not macOS, returning true');
+    return true;
+  }
+
+  const currentStatus = getPermissionStatus('camera');
+  logger.info(`[Camera] Current status: ${currentStatus}`);
+
+  if (currentStatus === 'granted') {
+    logger.info('[Camera] Already granted');
+    return true;
+  }
+
+  if (currentStatus === 'not-determined') {
+    logger.info('[Camera] Status is not-determined, requesting access...');
+    try {
+      const result = await askForCameraAccess();
+      logger.info(`[Camera] askForCameraAccess result: ${result}`);
+      return result === 'authorized';
+    } catch (error) {
+      logger.error('[Camera] askForCameraAccess failed:', error);
+      return false;
+    }
+  }
+
+  // If denied or restricted, open System Settings for manual enable
+  logger.info(`[Camera] Status is ${currentStatus}, opening System Settings...`);
+  await shell.openExternal(
+    'x-apple.systempreferences:com.apple.preference.security?Privacy_Camera',
+  );
+  return false;
+}
+
+/**
+ * Check if Screen Recording permission is granted
+ */
+export function getScreenCaptureStatus(): PermissionStatus {
+  return getPermissionStatus('screen');
+}
+
+/**
+ * Request Screen Recording permission
+ * Opens System Preferences if access not granted
+ * @param openPreferences - Whether to open System Preferences (default: true)
+ */
+export async function requestScreenCaptureAccess(openPreferences = true): Promise<boolean> {
+  if (!macOS()) {
+    logger.info('[Screen] Not macOS, returning true');
+    return true;
+  }
+
+  const currentStatus = getPermissionStatus('screen');
+  logger.info(`[Screen] Current status: ${currentStatus}`);
+
+  if (currentStatus === 'granted') {
+    logger.info('[Screen] Already granted');
+    return true;
+  }
+
+  // Request screen capture access - this will prompt the user or open settings
+  logger.info('[Screen] Requesting screen capture access...');
+  askForScreenCaptureAccess(openPreferences);
+
+  // Check the status after requesting
+  const newStatus = getPermissionStatus('screen');
+  logger.info(`[Screen] Status after request: ${newStatus}`);
+  return newStatus === 'granted';
+}
+
+/**
+ * Check if Full Disk Access permission is granted
+ */
+export function getFullDiskAccessStatus(): PermissionStatus {
+  return getPermissionStatus('full-disk-access');
+}
+
+/**
+ * Request Full Disk Access permission
+ * Opens System Preferences to the Full Disk Access pane
+ * Note: Full Disk Access cannot be granted programmatically,
+ * user must manually add the app in System Settings
+ */
+export function requestFullDiskAccess(): void {
+  if (!macOS()) {
+    logger.info('[FullDiskAccess] Not macOS, skipping');
+    return;
+  }
+
+  logger.info('[FullDiskAccess] Opening Full Disk Access settings...');
+  askForFullDiskAccess();
+}
+
+/**
+ * Open Full Disk Access settings page in System Settings
+ * Alternative method using shell.openExternal
+ */
+export async function openFullDiskAccessSettings(): Promise<void> {
+  if (!macOS()) {
+    logger.info('[FullDiskAccess] Not macOS, skipping');
+    return;
+  }
+
+  logger.info('[FullDiskAccess] Opening Full Disk Access settings via shell...');
+
+  // On macOS 13+ (Ventura), System Preferences is replaced by System Settings,
+  // and deep links may differ. We try multiple known schemes for compatibility.
+  const candidates = [
+    // macOS 13+ (Ventura and later) - System Settings
+    'x-apple.systempreferences:com.apple.settings.PrivacySecurity.extension?Privacy_AllFiles',
+    // macOS 13+ alternative format
+    'x-apple.systempreferences:com.apple.preference.security?Privacy_AllFiles',
+  ];
+
+  for (const url of candidates) {
+    try {
+      logger.info(`[FullDiskAccess] Trying URL: ${url}`);
+      await shell.openExternal(url);
+      logger.info(`[FullDiskAccess] Successfully opened via ${url}`);
+      return;
+    } catch (error) {
+      logger.warn(`[FullDiskAccess] Failed with URL ${url}:`, error);
+    }
+  }
+
+  // Fallback: open Privacy & Security pane
+  try {
+    const fallbackUrl = 'x-apple.systempreferences:com.apple.preference.security?Privacy';
+    logger.info(`[FullDiskAccess] Trying fallback URL: ${fallbackUrl}`);
+    await shell.openExternal(fallbackUrl);
+    logger.info('[FullDiskAccess] Opened Privacy & Security settings as fallback');
+  } catch (error) {
+    logger.error('[FullDiskAccess] Failed to open any Privacy settings:', error);
+  }
+}
+
+/**
+ * Check if Input Monitoring permission is granted
+ */
+export function getInputMonitoringStatus(): PermissionStatus {
+  return getPermissionStatus('input-monitoring');
+}
+
+/**
+ * Get media access status (compatibility wrapper for Electron API)
+ * Maps 'microphone' and 'screen' to corresponding permission checks
+ */
+export function getMediaAccessStatus(mediaType: 'microphone' | 'screen'): string {
+  if (!macOS()) return 'granted';
+
+  const status = getPermissionStatus(mediaType === 'microphone' ? 'microphone' : 'screen');
+
+  // Map our status back to Electron's expected format
+  switch (status) {
+    case 'granted': {
+      return 'granted';
+    }
+    case 'not-determined': {
+      return 'not-determined';
+    }
+    case 'denied': {
+      return 'denied';
+    }
+    case 'restricted': {
+      return 'restricted';
+    }
+    default: {
+      return 'unknown';
+    }
+  }
+}

package/apps/desktop/tsconfig.json

@@ -30,6 +30,7 @@
     "src/main/**/*",
     "src/preload/**/*",
     "src/common/**/*",
-    "electron-builder.js"
+    "electron-builder.js",
+    "native-deps.config.js"
   ]
 }

package/apps/desktop/vitest.config.mts

@@ -14,5 +14,6 @@ export default defineConfig({
       reportsDirectory: './coverage/app',
     },
     environment: 'node',
+    setupFiles: ['./src/main/__mocks__/setup.ts'],
   },
 });

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "features": [
+        "Update the cron patterns fields values."
+      ]
+    },
+    "date": "2026-01-10",
+    "version": "2.0.0-next.259"
+  },
   {
     "children": {
       "fixes": [

package/locales/en-US/setting.json

@@ -25,6 +25,7 @@
   "agentCronJobs.form.validation.nameRequired": "Task name is required",
   "agentCronJobs.interval.12hours": "Every 12 hours",
   "agentCronJobs.interval.1hour": "Every hour",
+  "agentCronJobs.interval.2hours": "Every 2 hours",
   "agentCronJobs.interval.30min": "Every 30 minutes",
   "agentCronJobs.interval.6hours": "Every 6 hours",
   "agentCronJobs.interval.daily": "Daily",

package/locales/zh-CN/setting.json

@@ -25,6 +25,7 @@
   "agentCronJobs.form.validation.nameRequired": "任务名称不能为空",
   "agentCronJobs.interval.12hours": "每12小时",
   "agentCronJobs.interval.1hour": "每小时",
+  "agentCronJobs.interval.2hours": "每2小时",
   "agentCronJobs.interval.30min": "每30分钟",
   "agentCronJobs.interval.6hours": "每6小时",
   "agentCronJobs.interval.daily": "每日",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.258",
+  "version": "2.0.0-next.259",
   "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",