@lobehub/lobehub 2.0.0-next.303 → 2.0.0-next.305

package/scripts/electronWorkflow/buildDesktopChannel.ts

@@ -0,0 +1,135 @@
+/* eslint-disable unicorn/no-process-exit */
+import fs from 'fs-extra';
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+
+type ReleaseChannel = 'stable' | 'beta' | 'nightly';
+
+const rootDir = path.resolve(__dirname, '../..');
+const desktopDir = path.join(rootDir, 'apps/desktop');
+const desktopPackageJsonPath = path.join(desktopDir, 'package.json');
+const buildDir = path.join(desktopDir, 'build');
+
+const iconTargets = ['icon.png', 'Icon.icns', 'icon.ico'];
+
+const isFlag = (value: string) => value.startsWith('-');
+
+const parseArgs = (args: string[]) => {
+  let channel = '';
+  let version = '';
+  let keepChanges = false;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+
+    if (arg === '--channel' || arg === '-c') {
+      channel = args[i + 1] ?? '';
+      i += 1;
+      continue;
+    }
+
+    if (arg === '--version' || arg === '-v') {
+      version = args[i + 1] ?? '';
+      i += 1;
+      continue;
+    }
+
+    if (arg === '--keep-changes') {
+      keepChanges = true;
+      continue;
+    }
+
+    if (!isFlag(arg)) {
+      if (!channel) {
+        channel = arg;
+        continue;
+      }
+
+      if (!version) {
+        version = arg;
+      }
+    }
+  }
+
+  return { channel, keepChanges, version };
+};
+
+const resolveDefaultVersion = () => {
+  const rootPackageJsonPath = path.join(rootDir, 'package.json');
+  const rootPackageJson = fs.readJsonSync(rootPackageJsonPath);
+  return rootPackageJson.version as string | undefined;
+};
+
+const backupFile = async (filePath: string) => {
+  try {
+    return await fs.readFile(filePath);
+  } catch {
+    return undefined;
+  }
+};
+
+const restoreFile = async (filePath: string, content?: Buffer) => {
+  if (!content) return;
+  await fs.writeFile(filePath, content);
+};
+
+const validateChannel = (channel: string): channel is ReleaseChannel =>
+  channel === 'stable' || channel === 'beta' || channel === 'nightly';
+
+const runCommand = (command: string, env?: Record<string, string | undefined>) => {
+  execSync(command, {
+    cwd: rootDir,
+    env: { ...process.env, ...env },
+    stdio: 'inherit',
+  });
+};
+
+const main = async () => {
+  const { channel, version: rawVersion, keepChanges } = parseArgs(process.argv.slice(2));
+
+  if (!validateChannel(channel)) {
+    console.error(
+      'Missing or invalid channel. Usage: npm run desktop:build-channel -- <stable|beta|nightly> [version] [--keep-changes]',
+    );
+    process.exit(1);
+  }
+
+  const version = rawVersion || resolveDefaultVersion();
+
+  if (!version) {
+    console.error('Missing version. Provide it or ensure root package.json has a version.');
+    process.exit(1);
+  }
+
+  const packageJsonBackup = await backupFile(desktopPackageJsonPath);
+  const iconBackups = await Promise.all(
+    iconTargets.map(async (fileName) => ({
+      content: await backupFile(path.join(buildDir, fileName)),
+      fileName,
+    })),
+  );
+
+  console.log(`🚦 CI-style build channel: ${channel}`);
+  console.log(`🏷️  Desktop version: ${version}`);
+  console.log(`🧩 Keep local changes: ${keepChanges ? 'yes' : 'no'}`);
+
+  try {
+    runCommand(`npm run workflow:set-desktop-version ${version} ${channel}`);
+    runCommand('npm run desktop:build', { UPDATE_CHANNEL: channel });
+  } catch (error) {
+    console.error('❌ Build failed:', error);
+    process.exit(1);
+  } finally {
+    if (!keepChanges) {
+      await restoreFile(desktopPackageJsonPath, packageJsonBackup);
+      await Promise.all(
+        iconBackups.map(({ fileName, content }) =>
+          restoreFile(path.join(buildDir, fileName), content),
+        ),
+      );
+      console.log('🧹 Restored local desktop package metadata and icons.');
+    }
+  }
+};
+
+main();

package/src/app/[variants]/(main)/_layout/index.tsx

@@ -12,6 +12,7 @@ import Loading from '@/components/Loading/BrandTextLoading';
 import { isDesktop } from '@/const/version';
 import { BANNER_HEIGHT } from '@/features/AlertBanner/CloudBanner';
 import DesktopNavigationBridge from '@/features/DesktopNavigationBridge';
+import AuthRequiredModal from '@/features/Electron/AuthRequiredModal';
 import TitleBar from '@/features/Electron/titlebar/TitleBar';
 import HotkeyHelperPanel from '@/features/HotkeyHelperPanel';
 import NavPanel from '@/features/NavPanel';
@@ -45,6 +46,7 @@ const Layout: FC = () => {
         {isDesktop && <TitleBar />}
         {isDesktop && <DesktopAutoOidcOnFirstOpen />}
         {isDesktop && <DesktopNavigationBridge />}
+        {isDesktop && <AuthRequiredModal />}
         {showCloudPromotion && <CloudBanner />}
       </Suspense>
       <DndContextWrapper>

package/src/features/Conversation/ChatList/components/AutoScroll.tsx

@@ -2,19 +2,13 @@
 
 import { memo, useEffect } from 'react';
 
-import { useConversationStore, virtuaListSelectors } from '../../store';
+import { messageStateSelectors, useConversationStore, virtuaListSelectors } from '../../store';
 import BackBottom from './BackBottom';
 
-interface AutoScrollProps {
-  /**
-   * Whether AI is generating (for auto-scroll during generation)
-   */
-  isGenerating?: boolean;
-}
-
-const AutoScroll = memo<AutoScrollProps>(({ isGenerating }) => {
+const AutoScroll = memo(() => {
   const atBottom = useConversationStore(virtuaListSelectors.atBottom);
   const isScrolling = useConversationStore(virtuaListSelectors.isScrolling);
+  const isGenerating = useConversationStore(messageStateSelectors.isAIGenerating);
   const scrollToBottom = useConversationStore((s) => s.scrollToBottom);
 
   useEffect(() => {

package/src/features/Conversation/ChatList/components/VirtualizedList.tsx

@@ -10,10 +10,6 @@ import AutoScroll from './AutoScroll';
 
 interface VirtualizedListProps {
   dataSource: string[];
-  /**
-   * Whether AI is generating (for auto-scroll)
-   */
-  isGenerating?: boolean;
   itemContent: (index: number, data: string) => ReactNode;
 }
 
@@ -22,7 +18,7 @@ interface VirtualizedListProps {
  *
  * Based on ConversationStore data flow, no dependency on global ChatStore.
  */
-const VirtualizedList = memo<VirtualizedListProps>(({ dataSource, itemContent, isGenerating }) => {
+const VirtualizedList = memo<VirtualizedListProps>(({ dataSource, itemContent }) => {
   const virtuaRef = useRef<VListHandle>(null);
   const prevDataLengthRef = useRef(dataSource.length);
   const scrollEndTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
@@ -154,7 +150,7 @@ const VirtualizedList = memo<VirtualizedListProps>(({ dataSource, itemContent, i
           position: 'relative',
         }}
       >
-        <AutoScroll isGenerating={isGenerating} />
+        <AutoScroll />
       </WideScreenContainer>
     </>
   );

package/src/features/DesktopNavigationBridge/index.tsx

@@ -4,8 +4,6 @@ import { useWatchBroadcast } from '@lobechat/electron-client-ipc';
 import { memo, useCallback } from 'react';
 import { useNavigate } from 'react-router-dom';
 
-import { clearDesktopOnboardingCompleted } from '@/app/[variants]/(desktop)/desktop-onboarding/storage';
-
 const DesktopNavigationBridge = memo(() => {
   const navigate = useNavigate();
 
@@ -19,13 +17,6 @@ const DesktopNavigationBridge = memo(() => {
 
   useWatchBroadcast('navigate', handleNavigate);
 
-  const handleAuthorizationRequired = useCallback(() => {
-    clearDesktopOnboardingCompleted();
-    navigate('/desktop-onboarding#5', { replace: true });
-  }, [navigate]);
-
-  useWatchBroadcast('authorizationRequired', handleAuthorizationRequired);
-
   return null;
 });
 

package/src/features/Electron/AuthRequiredModal/index.tsx

@@ -0,0 +1,151 @@
+'use client';
+
+import { useWatchBroadcast } from '@lobechat/electron-client-ipc';
+import { Button, Flexbox, Icon, type ModalInstance, createModal } from '@lobehub/ui';
+import { AlertCircle, LogIn } from 'lucide-react';
+import { type ReactNode, memo, useCallback, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { useElectronStore } from '@/store/electron';
+
+interface ModalUpdateOptions {
+  closable?: boolean;
+  keyboard?: boolean;
+  maskClosable?: boolean;
+  title?: ReactNode;
+}
+
+interface AuthRequiredModalContentProps {
+  onClose: () => void;
+  setModalProps: (props: ModalUpdateOptions) => void;
+}
+
+const AuthRequiredModalContent = memo<AuthRequiredModalContentProps>(
+  ({ onClose, setModalProps }) => {
+    const { t } = useTranslation('auth');
+    const [isSigningIn, setIsSigningIn] = useState(false);
+    const isClosingRef = useRef(false);
+
+    const [dataSyncConfig, connectRemoteServer, refreshServerConfig, clearRemoteServerSyncError] =
+      useElectronStore((s) => [
+        s.dataSyncConfig,
+        s.connectRemoteServer,
+        s.refreshServerConfig,
+        s.clearRemoteServerSyncError,
+      ]);
+
+    // Update modal props based on signing in state
+    setModalProps({
+      closable: !isSigningIn,
+      keyboard: !isSigningIn,
+      maskClosable: !isSigningIn,
+      title: (
+        <Flexbox align="center" gap={8} horizontal>
+          <Icon icon={AlertCircle} />
+          {t('authModal.title')}
+        </Flexbox>
+      ),
+    });
+
+    // Listen for successful authorization to close the modal
+    useWatchBroadcast('authorizationSuccessful', async () => {
+      if (isClosingRef.current) return;
+      isClosingRef.current = true;
+      setIsSigningIn(false);
+      onClose();
+      await refreshServerConfig();
+    });
+
+    // Listen for authorization failure
+    useWatchBroadcast('authorizationFailed', () => {
+      setIsSigningIn(false);
+    });
+
+    const handleSignIn = useCallback(async () => {
+      setIsSigningIn(true);
+      clearRemoteServerSyncError();
+
+      await connectRemoteServer({
+        remoteServerUrl: dataSyncConfig?.remoteServerUrl,
+        storageMode: dataSyncConfig?.storageMode || 'cloud',
+      });
+    }, [clearRemoteServerSyncError, connectRemoteServer, dataSyncConfig]);
+
+    const handleLater = useCallback(() => {
+      if (isClosingRef.current) return;
+      isClosingRef.current = true;
+      onClose();
+    }, [onClose]);
+
+    return (
+      <Flexbox gap={16} style={{ padding: 16 }}>
+        <p style={{ margin: 0 }}>{t('authModal.description')}</p>
+        <Flexbox gap={8} horizontal justify="flex-end">
+          <Button disabled={isSigningIn} onClick={handleLater}>
+            {t('authModal.later')}
+          </Button>
+          <Button
+            icon={<Icon icon={LogIn} />}
+            loading={isSigningIn}
+            onClick={handleSignIn}
+            type="primary"
+          >
+            {isSigningIn ? t('authModal.signingIn') : t('authModal.signIn')}
+          </Button>
+        </Flexbox>
+      </Flexbox>
+    );
+  },
+);
+
+AuthRequiredModalContent.displayName = 'AuthRequiredModalContent';
+
+/**
+ * Hook to create and manage the auth required modal
+ */
+export const useAuthRequiredModal = () => {
+  const instanceRef = useRef<ModalInstance | null>(null);
+
+  const open = useCallback(() => {
+    // Don't open multiple modals
+    if (instanceRef.current) return;
+
+    const setModalProps = (nextProps: ModalUpdateOptions) => {
+      instanceRef.current?.update?.(nextProps);
+    };
+
+    const handleClose = () => {
+      instanceRef.current?.close();
+      instanceRef.current = null;
+    };
+
+    instanceRef.current = createModal({
+      children: <AuthRequiredModalContent onClose={handleClose} setModalProps={setModalProps} />,
+      closable: false,
+      footer: null,
+      keyboard: false,
+      maskClosable: false,
+      title: '',
+    });
+  }, []);
+
+  return { open };
+};
+
+/**
+ * Component that listens for authorizationRequired IPC events and opens the modal
+ */
+const AuthRequiredModal = memo(() => {
+  const { open } = useAuthRequiredModal();
+
+  // Listen for IPC event to open the modal
+  useWatchBroadcast('authorizationRequired', () => {
+    open();
+  });
+
+  return null;
+});
+
+AuthRequiredModal.displayName = 'AuthRequiredModal';
+
+export default AuthRequiredModal;

package/src/locales/default/auth.ts

@@ -28,6 +28,12 @@ export default {
   'apikey.list.columns.status': 'Enabled Status',
   'apikey.list.title': 'API Key List',
   'apikey.validation.required': 'This field cannot be empty',
+  'authModal.description':
+    'Your login session has expired. Please sign in again to continue using cloud sync features.',
+  'authModal.later': 'Later',
+  'authModal.signIn': 'Sign In Again',
+  'authModal.signingIn': 'Signing in...',
+  'authModal.title': 'Session Expired',
   'betterAuth.errors.confirmPasswordRequired': 'Please confirm your password',
   'betterAuth.errors.emailExists': 'This email is already registered. Please sign in instead',
   'betterAuth.errors.emailInvalid': 'Please enter a valid email address or username',

package/src/locales/default/plugin.ts

@@ -70,6 +70,7 @@ export default {
   'builtins.lobe-group-management.apiName.summarize': 'Summarize conversation',
   'builtins.lobe-group-management.apiName.vote': 'Start vote',
   'builtins.lobe-group-management.inspector.broadcast.title': 'Following Agents speak:',
+  'builtins.lobe-group-management.inspector.executeAgentTask.title': 'Assigning task to:',
   'builtins.lobe-group-management.inspector.executeAgentTasks.title': 'Assigning tasks to:',
   'builtins.lobe-group-management.inspector.speak.title': 'Designated Agent speaks:',
   'builtins.lobe-group-management.title': 'Group Coordinator',

package/src/utils/errorResponse.ts

@@ -1,6 +1,16 @@
 import { AgentRuntimeErrorType, type ILobeAgentRuntimeErrorType } from '@lobechat/model-runtime';
 import { ChatErrorType, type ErrorResponse, type ErrorType } from '@lobechat/types';
 
+/**
+ * Error types that indicate a real authentication failure.
+ * When these errors occur, the response will include X-Auth-Required header
+ * to signal the client that re-authentication is needed.
+ */
+const AUTH_REQUIRED_ERROR_TYPES = new Set<ErrorType>([
+  ChatErrorType.Unauthorized,
+  ChatErrorType.InvalidClerkUser,
+]);
+
 const getStatus = (errorType: ILobeAgentRuntimeErrorType | ErrorType) => {
   // InvalidAccessCode / InvalidAzureAPIKey / InvalidOpenAIAPIKey / InvalidZhipuAPIKey ....
   if (errorType.toString().includes('Invalid')) return 401;
@@ -71,5 +81,15 @@ export const createErrorResponse = (
     );
   }
 
-  return new Response(JSON.stringify(data), { status: statusCode });
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  };
+
+  // Add X-Auth-Required header for real authentication failures
+  // This allows the client to distinguish between auth failures and other 401 errors (e.g., invalid API keys)
+  if (AUTH_REQUIRED_ERROR_TYPES.has(errorType as ErrorType)) {
+    headers['X-Auth-Required'] = 'true';
+  }
+
+  return new Response(JSON.stringify(data), { headers, status: statusCode });
 };