@lobehub/lobehub 2.0.0-next.304 → 2.0.0-next.306

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/app/[variants]/(main)/community/(detail)/assistant/index.tsx

@@ -40,7 +40,7 @@ const AssistantDetailPage = memo<AssistantDetailPageProps>(({ mobile }) => {
   return (
     <TocProvider>
       <DetailProvider config={data}>
-        <Flexbox gap={16}>
+        <Flexbox data-testid="assistant-detail-content" gap={16}>
           <Header mobile={mobile} />
           <Details mobile={mobile} />
         </Flexbox>

package/src/app/[variants]/(main)/community/(detail)/mcp/index.tsx

@@ -35,7 +35,7 @@ const McpDetailPage = memo<McpDetailPageProps>(({ mobile }) => {
   return (
     <TocProvider>
       <DetailProvider config={data}>
-        <Flexbox gap={16}>
+        <Flexbox data-testid="mcp-detail-content" gap={16}>
           <Header mobile={mobile} />
           <Details mobile={mobile} />
         </Flexbox>

package/src/app/[variants]/(main)/group/features/Conversation/MainChatInput/index.tsx

@@ -11,10 +11,10 @@ import { useSendMenuItems } from './useSendMenuItems';
 const leftActions: ActionKeys[] = [
   'model',
   'search',
-  'typo',
   'fileUpload',
+  'tools',
   '---',
-  ['tools', 'params', 'clear'],
+  ['typo', 'params', 'clear'],
   'mainToken',
 ];
 

package/src/app/[variants]/(main)/home/_layout/Body/Agent/List/AgentItem/index.tsx

@@ -37,8 +37,8 @@ const AgentItem = memo<AgentItemProps>(({ item, style, className }) => {
     s.agentUpdatingId === id,
   ]);
 
-  // Separate loading state from chat store - only subscribe if this session is active
-  const isLoading = useChatStore(operationSelectors.isAgentRuntimeRunning);
+  // Separate loading state from chat store - only show loading for this specific agent
+  const isLoading = useChatStore(operationSelectors.isAgentRunning(id));
 
   // Get display title with fallback
   const displayTitle = title || t('untitledAgent');

package/src/features/Conversation/Messages/Supervisor/index.tsx

@@ -55,7 +55,8 @@ const GroupMessage = memo<GroupMessageProps>(({ id, index, disableEditing, isLat
 
   // Get editing state from ConversationStore
   const creating = useConversationStore(messageStateSelectors.isMessageCreating(id));
-  const newScreen = useNewScreen({ creating, isLatestItem });
+  const generating = useConversationStore(messageStateSelectors.isMessageGenerating(id));
+  const newScreen = useNewScreen({ creating: creating || generating, isLatestItem });
 
   const setMessageItemActionElementPortialContext = useSetMessageItemActionElementPortialContext();
   const setMessageItemActionTypeContext = useSetMessageItemActionTypeContext();

package/src/features/Conversation/Messages/components/ContentLoading.tsx

@@ -18,10 +18,11 @@ interface ContentLoadingProps {
 const ContentLoading = memo<ContentLoadingProps>(({ id }) => {
   const { t } = useTranslation('chat');
   const runningOp = useChatStore(operationSelectors.getDeepestRunningOperationByMessage(id));
+  console.log('runningOp', runningOp);
   const [elapsedSeconds, setElapsedSeconds] = useState(0);
+  const [startTime, setStartTime] = useState(runningOp?.metadata?.startTime);
 
   const operationType = runningOp?.type as OperationType | undefined;
-  const startTime = runningOp?.metadata?.startTime;
 
   // Track elapsed time, reset when operation type changes
   useEffect(() => {
@@ -39,7 +40,12 @@ const ContentLoading = memo<ContentLoadingProps>(({ id }) => {
     const interval = setInterval(updateElapsed, 1000);
 
     return () => clearInterval(interval);
-  }, [startTime, operationType]);
+  }, [startTime]);
+
+  useEffect(() => {
+    setElapsedSeconds(0);
+    setStartTime(Date.now());
+  }, [operationType, id]);
 
   // Get localized label based on operation type
   const operationLabel = operationType

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/services/chat/mecha/agentConfigResolver.ts

@@ -5,6 +5,7 @@ import {
   type LobeAgentConfig,
   type MessageMapScope,
 } from '@lobechat/types';
+import debug from 'debug';
 import { produce } from 'immer';
 
 import { getAgentStoreState } from '@/store/agent';
@@ -12,6 +13,8 @@ import { agentSelectors, chatConfigByIdSelectors } from '@/store/agent/selectors
 import { getChatGroupStoreState } from '@/store/agentGroup';
 import { agentGroupByIdSelectors, agentGroupSelectors } from '@/store/agentGroup/selectors';
 
+const log = debug('mecha:agentConfigResolver');
+
 /**
  * Applies params adjustments based on chatConfig settings.
  *
@@ -99,6 +102,8 @@ export interface ResolvedAgentConfig {
 export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAgentConfig => {
   const { agentId, model, documentContent, plugins, targetAgentConfig } = ctx;
 
+  log('resolveAgentConfig called with agentId: %s, scope: %s', agentId, ctx.scope);
+
   const agentStoreState = getAgentStoreState();
 
   // Get base config from store
@@ -111,19 +116,46 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
   // Check if this is a builtin agent
   // First check agent store, then check if this is a supervisor agent in agentGroup store
   let slug = agentSelectors.getAgentSlugById(agentId)(agentStoreState);
+  log('slug from agentStore: %s (agentId: %s)', slug, agentId);
 
   // If not found in agent store, check if this is a supervisor agent in any group
   // Supervisor agents have their slug stored in agentGroup store, not agent store
   if (!slug) {
     const groupStoreState = getChatGroupStoreState();
+    const groupMap = groupStoreState.groupMap;
+    const groupMapKeys = Object.keys(groupMap);
+    log(
+      'checking groupStore for supervisor - groupMap has %d groups: %o',
+      groupMapKeys.length,
+      groupMapKeys.map((key) => ({
+        groupId: key,
+        supervisorAgentId: groupMap[key]?.supervisorAgentId,
+        title: groupMap[key]?.title,
+      })),
+    );
+
     const group = agentGroupByIdSelectors.groupBySupervisorAgentId(agentId)(groupStoreState);
+    log(
+      'groupBySupervisorAgentId result for agentId %s: %o',
+      agentId,
+      group
+        ? {
+            groupId: group.id,
+            supervisorAgentId: group.supervisorAgentId,
+            title: group.title,
+          }
+        : null,
+    );
+
     if (group) {
       // This is a supervisor agent - use the builtin slug
       slug = BUILTIN_AGENT_SLUGS.groupSupervisor;
+      log('agentId %s identified as group supervisor, assigned slug: %s', agentId, slug);
     }
   }
 
   if (!slug) {
+    log('agentId %s is not a builtin agent (no slug found)', agentId);
     // Regular agent - use provided plugins if available, fallback to agent's plugins
     const finalPlugins = plugins && plugins.length > 0 ? plugins : basePlugins;
 
@@ -183,18 +215,45 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
   // Build groupSupervisorContext if this is a group-supervisor agent
   let groupSupervisorContext;
   if (slug === BUILTIN_AGENT_SLUGS.groupSupervisor) {
+    log('building groupSupervisorContext for agentId: %s', agentId);
     const groupStoreState = getChatGroupStoreState();
     // Find the group by supervisor agent ID
     const group = agentGroupSelectors.getGroupBySupervisorAgentId(agentId)(groupStoreState);
 
+    log(
+      'getGroupBySupervisorAgentId result: %o',
+      group
+        ? {
+            agentsCount: group.agents?.length,
+            groupId: group.id,
+            supervisorAgentId: group.supervisorAgentId,
+            title: group.title,
+          }
+        : null,
+    );
+
     if (group) {
       const groupMembers = agentGroupSelectors.getGroupMembers(group.id)(groupStoreState);
+      log(
+        'groupMembers for groupId %s: %o',
+        group.id,
+        groupMembers.map((m) => ({ id: m.id, isSupervisor: m.isSupervisor, title: m.title })),
+      );
+
       groupSupervisorContext = {
         availableAgents: groupMembers.map((agent) => ({ id: agent.id, title: agent.title })),
         groupId: group.id,
         groupTitle: group.title || 'Group Chat',
         systemPrompt: agentConfig.systemRole,
       };
+      log('groupSupervisorContext built: %o', {
+        availableAgentsCount: groupSupervisorContext.availableAgents.length,
+        groupId: groupSupervisorContext.groupId,
+        groupTitle: groupSupervisorContext.groupTitle,
+        hasSystemPrompt: !!groupSupervisorContext.systemPrompt,
+      });
+    } else {
+      log('WARNING: group not found for supervisor agentId: %s', agentId);
     }
   }
 
@@ -258,6 +317,12 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
   // Apply params adjustments based on chatConfig
   const finalAgentConfig = applyParamsFromChatConfig(resolvedAgentConfig, resolvedChatConfig);
 
+  log('resolveAgentConfig completed for agentId: %s, result: %o', agentId, {
+    isBuiltinAgent: true,
+    pluginsCount: finalPlugins.length,
+    slug,
+  });
+
   return {
     agentConfig: finalAgentConfig,
     chatConfig: resolvedChatConfig,