@lobehub/lobehub 2.0.0-next.264 → 2.0.0-next.266

package/src/server/routers/lambda/agentGroup.ts

@@ -126,6 +126,22 @@ export const agentGroupRouter = router({
       return ctx.agentGroupService.deleteGroup(input.id);
     }),
 
+  /**
+   * Duplicate a chat group with all its members.
+   * Creates a new group with the same config, a new supervisor, and copies of virtual members.
+   * Non-virtual members are referenced (not copied).
+   */
+  duplicateGroup: agentGroupProcedure
+    .input(
+      z.object({
+        groupId: z.string(),
+        newTitle: z.string().optional(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.agentGroupRepo.duplicate(input.groupId, input.newTitle);
+    }),
+
   getGroup: agentGroupProcedure
     .input(z.object({ id: z.string() }))
     .query(async ({ input, ctx }) => {

package/src/services/agent.ts

@@ -185,6 +185,17 @@ class AgentService {
   updateAgentPinned = async (agentId: string, pinned: boolean) => {
     return lambdaClient.agent.updateAgentPinned.mutate({ id: agentId, pinned });
   };
+
+  /**
+   * Duplicate an agent.
+   * Returns the new agent ID.
+   */
+  duplicateAgent = async (
+    agentId: string,
+    newTitle?: string,
+  ): Promise<{ agentId: string } | null> => {
+    return lambdaClient.agent.duplicateAgent.mutate({ agentId, newTitle });
+  };
 }
 
 export const agentService = new AgentService();

package/src/services/chatGroup/index.ts

@@ -107,6 +107,17 @@ class ChatGroupService {
   getGroupAgents = (groupId: string): Promise<ChatGroupAgentItem[]> => {
     return lambdaClient.group.getGroupAgents.query({ groupId });
   };
+
+  /**
+   * Duplicate a chat group with all its members.
+   * Returns the new group ID and supervisor agent ID.
+   */
+  duplicateGroup = (
+    groupId: string,
+    newTitle?: string,
+  ): Promise<{ groupId: string; supervisorAgentId: string } | null> => {
+    return lambdaClient.group.duplicateGroup.mutate({ groupId, newTitle });
+  };
 }
 
 export const chatGroupService = new ChatGroupService();

package/src/store/agent/slices/cron/action.ts

@@ -0,0 +1,108 @@
+import { ENABLE_BUSINESS_FEATURES } from '@lobechat/business-const';
+import type { SWRResponse } from 'swr';
+import { type StateCreator } from 'zustand/vanilla';
+
+import type { AgentCronJob } from '@/database/schemas/agentCronJob';
+import { mutate, useClientDataSWR } from '@/libs/swr';
+import { lambdaClient } from '@/libs/trpc/client/lambda';
+import { agentCronJobService } from '@/services/agentCronJob';
+
+import type { AgentStore } from '../../store';
+
+const FETCH_CRON_TOPICS_WITH_JOB_INFO_KEY = 'cronTopicsWithJobInfo';
+
+export interface CronTopicGroupWithJobInfo {
+  cronJob: AgentCronJob | null;
+  cronJobId: string;
+  topics: Array<{
+    createdAt: Date | string;
+    favorite?: boolean | null;
+    historySummary?: string | null;
+    id: string;
+    metadata?: any;
+    title?: string | null;
+    trigger?: string | null;
+    updatedAt: Date | string;
+  }>;
+}
+
+/**
+ * Cron Slice Actions
+ * Handles agent cron job operations
+ */
+export interface CronSliceAction {
+  createAgentCronJob: () => Promise<string | null>;
+  internal_refreshCronTopics: () => Promise<void>;
+  useFetchCronTopicsWithJobInfo: (agentId?: string) => SWRResponse<CronTopicGroupWithJobInfo[]>;
+}
+
+export const createCronSlice: StateCreator<
+  AgentStore,
+  [['zustand/devtools', never]],
+  [],
+  CronSliceAction
+> = (set, get) => ({
+  createAgentCronJob: async () => {
+    const { activeAgentId, internal_refreshCronTopics } = get();
+    if (!activeAgentId) return null;
+
+    try {
+      const result = await agentCronJobService.create({
+        agentId: activeAgentId,
+        content: '',
+        cronPattern: '*/30 * * * *',
+        enabled: false,
+      });
+
+      if (result.success) {
+        await internal_refreshCronTopics();
+        return result.data.id;
+      }
+      return null;
+    } catch (error) {
+      console.error('Failed to create cron job:', error);
+      return null;
+    }
+  },
+
+  internal_refreshCronTopics: async () => {
+    await mutate([FETCH_CRON_TOPICS_WITH_JOB_INFO_KEY, get().activeAgentId]);
+  },
+
+  useFetchCronTopicsWithJobInfo: (agentId) =>
+    useClientDataSWR<CronTopicGroupWithJobInfo[]>(
+      ENABLE_BUSINESS_FEATURES && agentId ? [FETCH_CRON_TOPICS_WITH_JOB_INFO_KEY, agentId] : null,
+      async ([, id]: [string, string]) => {
+        const [cronJobsResult, cronTopicsGroups] = await Promise.all([
+          lambdaClient.agentCronJob.findByAgent.query({ agentId: id }),
+          lambdaClient.topic.getCronTopicsGroupedByCronJob.query({ agentId: id }),
+        ]);
+
+        const cronJobs = cronJobsResult.success ? cronJobsResult.data : [];
+        const topicsByCronId = new Map(
+          cronTopicsGroups.map((group) => [group.cronJobId, group.topics]),
+        );
+        const cronJobIds = new Set(cronJobs.map((job) => job.id));
+
+        const groupsWithJobs = cronJobs.map((job) => ({
+          cronJob: job,
+          cronJobId: job.id,
+          topics: topicsByCronId.get(job.id) || [],
+        }));
+
+        const orphanGroups = cronTopicsGroups
+          .filter((group) => !cronJobIds.has(group.cronJobId))
+          .map((group) => ({
+            cronJob: null,
+            cronJobId: group.cronJobId,
+            topics: group.topics,
+          }));
+
+        return [...groupsWithJobs, ...orphanGroups];
+      },
+      {
+        fallbackData: [],
+        revalidateOnFocus: false,
+      },
+    ),
+});

package/src/store/agent/slices/cron/index.ts

@@ -0,0 +1 @@
+export { createCronSlice, type CronSliceAction } from './action';

package/src/store/agent/store.ts

@@ -6,6 +6,7 @@ import { createDevtools } from '../middleware/createDevtools';
 import { type AgentStoreState, initialState } from './initialState';
 import { type AgentSliceAction, createAgentSlice } from './slices/agent';
 import { type BuiltinAgentSliceAction, createBuiltinAgentSlice } from './slices/builtin';
+import { type CronSliceAction, createCronSlice } from './slices/cron';
 import { type KnowledgeSliceAction, createKnowledgeSlice } from './slices/knowledge';
 import { type PluginSliceAction, createPluginSlice } from './slices/plugin';
 
@@ -15,6 +16,7 @@ export interface AgentStore
   extends
     AgentSliceAction,
     BuiltinAgentSliceAction,
+    CronSliceAction,
     KnowledgeSliceAction,
     PluginSliceAction,
     AgentStoreState {}
@@ -23,6 +25,7 @@ const createStore: StateCreator<AgentStore, [['zustand/devtools', never]]> = (..
   ...initialState,
   ...createAgentSlice(...parameters),
   ...createBuiltinAgentSlice(...parameters),
+  ...createCronSlice(...parameters),
   ...createKnowledgeSlice(...parameters),
   ...createPluginSlice(...parameters),
 });

package/src/store/home/slices/sidebarUI/action.test.ts

@@ -6,6 +6,7 @@ import { agentService } from '@/services/agent';
 import { chatGroupService } from '@/services/chatGroup';
 import { homeService } from '@/services/home';
 import { sessionService } from '@/services/session';
+import { getAgentStoreState } from '@/store/agent';
 import { useHomeStore } from '@/store/home';
 import { getSessionStoreState } from '@/store/session';
 
@@ -26,6 +27,12 @@ vi.mock('@/store/session', () => ({
   })),
 }));
 
+vi.mock('@/store/agent', () => ({
+  getAgentStoreState: vi.fn(() => ({
+    setActiveAgentId: vi.fn(),
+  })),
+}));
+
 afterEach(() => {
   vi.restoreAllMocks();
 });
@@ -136,17 +143,16 @@ describe('createSidebarUISlice', () => {
   });
 
   describe('duplicateAgent', () => {
-    it('should duplicate an agent and switch to the new session', async () => {
+    it('should duplicate an agent and switch to the new agent', async () => {
       const mockAgentId = 'agent-123';
-      const mockNewId = 'new-agent-456';
-      const mockSwitchSession = vi.fn();
+      const mockNewAgentId = 'new-agent-456';
+      const mockSetActiveAgentId = vi.fn();
 
-      vi.mocked(getSessionStoreState).mockReturnValue({
-        activeId: 'other-agent',
-        switchSession: mockSwitchSession,
+      vi.mocked(getAgentStoreState).mockReturnValue({
+        setActiveAgentId: mockSetActiveAgentId,
       } as any);
 
-      vi.spyOn(sessionService, 'cloneSession').mockResolvedValueOnce(mockNewId);
+      vi.spyOn(agentService, 'duplicateAgent').mockResolvedValueOnce({ agentId: mockNewAgentId });
       const spyOnRefresh = vi.spyOn(useHomeStore.getState(), 'refreshAgentList');
 
       const { result } = renderHook(() => useHomeStore());
@@ -155,16 +161,16 @@ describe('createSidebarUISlice', () => {
         await result.current.duplicateAgent(mockAgentId, 'Copied Agent');
       });
 
-      expect(sessionService.cloneSession).toHaveBeenCalledWith(mockAgentId, 'Copied Agent');
+      expect(agentService.duplicateAgent).toHaveBeenCalledWith(mockAgentId, 'Copied Agent');
       expect(spyOnRefresh).toHaveBeenCalled();
-      expect(mockSwitchSession).toHaveBeenCalledWith(mockNewId);
+      expect(mockSetActiveAgentId).toHaveBeenCalledWith(mockNewAgentId);
     });
 
     it('should show error message when duplication fails', async () => {
       const mockAgentId = 'agent-123';
       const { message } = await import('@/components/AntdStaticMethods');
 
-      vi.spyOn(sessionService, 'cloneSession').mockResolvedValueOnce(undefined);
+      vi.spyOn(agentService, 'duplicateAgent').mockResolvedValueOnce(null);
       vi.spyOn(useHomeStore.getState(), 'refreshAgentList');
 
       const { result } = renderHook(() => useHomeStore());
@@ -176,29 +182,24 @@ describe('createSidebarUISlice', () => {
       expect(message.error).toHaveBeenCalled();
     });
 
-    it('should use default title when not provided', async () => {
+    it('should use provided title when duplicating', async () => {
       const mockAgentId = 'agent-123';
-      const mockNewId = 'new-agent-456';
+      const mockNewAgentId = 'new-agent-456';
 
-      vi.mocked(getSessionStoreState).mockReturnValue({
-        activeId: 'other-agent',
-        switchSession: vi.fn(),
+      vi.mocked(getAgentStoreState).mockReturnValue({
+        setActiveAgentId: vi.fn(),
       } as any);
 
-      vi.spyOn(sessionService, 'cloneSession').mockResolvedValueOnce(mockNewId);
+      vi.spyOn(agentService, 'duplicateAgent').mockResolvedValueOnce({ agentId: mockNewAgentId });
       vi.spyOn(useHomeStore.getState(), 'refreshAgentList');
 
       const { result } = renderHook(() => useHomeStore());
 
       await act(async () => {
-        await result.current.duplicateAgent(mockAgentId);
+        await result.current.duplicateAgent(mockAgentId, 'Custom Title');
       });
 
-      // default title is i18n based
-      expect(sessionService.cloneSession).toHaveBeenCalledWith(
-        mockAgentId,
-        expect.stringContaining('Copy'),
-      );
+      expect(agentService.duplicateAgent).toHaveBeenCalledWith(mockAgentId, 'Custom Title');
     });
   });
 

package/src/store/home/slices/sidebarUI/action.ts

@@ -7,8 +7,8 @@ import { agentService } from '@/services/agent';
 import { chatGroupService } from '@/services/chatGroup';
 import { homeService } from '@/services/home';
 import { sessionService } from '@/services/session';
+import { getAgentStoreState } from '@/store/agent';
 import type { HomeStore } from '@/store/home/store';
-import { getSessionStoreState } from '@/store/session';
 import { type SessionGroupItem } from '@/types/session';
 import { setNamespace } from '@/utils/storeDebug';
 
@@ -17,9 +17,13 @@ const n = setNamespace('sidebarUI');
 export interface SidebarUIAction {
   // ========== Agent Operations ==========
   /**
-   * Duplicate an agent
+   * Duplicate an agent using agentService
    */
   duplicateAgent: (agentId: string, newTitle?: string) => Promise<void>;
+  /**
+   * Duplicate a chat group (multi-agent group)
+   */
+  duplicateAgentGroup: (groupId: string, newTitle?: string) => Promise<void>;
   /**
    * Pin or unpin an agent
    */
@@ -94,11 +98,35 @@ export const createSidebarUISlice: StateCreator<
       key: messageLoadingKey,
     });
 
-    // Use provided title or generate default
-    const title = newTitle ?? t('duplicateSession.title', { ns: 'chat', title: 'Agent' }) ?? 'Copy';
-    const newId = await sessionService.cloneSession(agentId, title);
+    const result = await agentService.duplicateAgent(agentId, newTitle);
+
+    if (!result) {
+      message.destroy(messageLoadingKey);
+      message.error(t('copyFail', { ns: 'common' }));
+      return;
+    }
+
+    await get().refreshAgentList();
+    message.destroy(messageLoadingKey);
+    message.success(t('duplicateSession.success', { ns: 'chat' }));
+
+    // Switch to the new agent
+    const agentStore = getAgentStoreState();
+    agentStore.setActiveAgentId(result.agentId);
+  },
+
+  duplicateAgentGroup: async (groupId, newTitle?: string) => {
+    const messageLoadingKey = 'duplicateAgentGroup.loading';
+
+    message.loading({
+      content: t('duplicateSession.loading', { ns: 'chat' }),
+      duration: 0,
+      key: messageLoadingKey,
+    });
+
+    const result = await chatGroupService.duplicateGroup(groupId, newTitle);
 
-    if (!newId) {
+    if (!result) {
       message.destroy(messageLoadingKey);
       message.error(t('copyFail', { ns: 'common' }));
       return;
@@ -108,9 +136,9 @@ export const createSidebarUISlice: StateCreator<
     message.destroy(messageLoadingKey);
     message.success(t('duplicateSession.success', { ns: 'chat' }));
 
-    // Switch to new session
-    const sessionStore = getSessionStoreState();
-    sessionStore.switchSession(newId);
+    // Switch to the new group (using supervisor agent id)
+    const agentStore = getAgentStoreState();
+    agentStore.setActiveAgentId(result.supervisorAgentId);
   },
 
   pinAgent: async (agentId, pinned) => {

package/src/app/[variants]/(main)/agent/_layout/Sidebar/Topic/CronTopicList/CronTopicGroup.tsx

@@ -1,74 +0,0 @@
-'use client';
-
-import { Flexbox, Icon, Text } from '@lobehub/ui';
-import { cssVar } from 'antd-style';
-import { Clock } from 'lucide-react';
-import { type MouseEvent, memo, useCallback } from 'react';
-import { useParams } from 'react-router-dom';
-
-import { useRouter } from '@/app/[variants]/(main)/hooks/useRouter';
-import type { AgentCronJob } from '@/database/schemas/agentCronJob';
-
-import CronTopicItem from './CronTopicItem';
-
-interface CronTopicGroupProps {
-  cronJob: AgentCronJob | null;
-  cronJobId: string;
-  topics: Array<{
-    createdAt: Date | string;
-    favorite?: boolean | null;
-    historySummary?: string | null;
-    id: string;
-    metadata?: any;
-    title?: string | null;
-    trigger?: string | null;
-    updatedAt: Date | string;
-  }>;
-}
-
-const CronTopicGroup = memo<CronTopicGroupProps>(({ cronJob, cronJobId, topics }) => {
-  const { aid } = useParams<{ aid?: string }>();
-  const router = useRouter();
-  const handleOpenCronJob = useCallback(
-    (event: MouseEvent) => {
-      event.stopPropagation();
-      if (!aid) return;
-      router.push(`/agent/${aid}/cron/${cronJobId}`);
-    },
-    [aid, cronJobId, router],
-  );
-
-  const cronJobName = cronJob?.name || `Cron Job ${cronJobId.slice(-8)}`;
-  const isEnabled = cronJob?.enabled ?? false;
-
-  return (
-    <Flexbox gap={1}>
-      <Flexbox
-        align="center"
-        gap={6}
-        height={24}
-        horizontal
-        onClick={handleOpenCronJob}
-        paddingInline={8}
-        style={{ cursor: 'pointer', opacity: isEnabled ? 1 : 0.6, overflow: 'hidden' }}
-      >
-        <Icon icon={Clock} style={{ color: cssVar.colorTextDescription, opacity: 0.7 }} />
-        <Text ellipsis fontSize={12} style={{ flex: 1 }} type={'secondary'} weight={500}>
-          {cronJobName}
-        </Text>
-        {topics.length > 0 && (
-          <Text style={{ color: cssVar.colorTextDescription, fontSize: 11 }}>{topics.length}</Text>
-        )}
-      </Flexbox>
-      {topics.length > 0 && (
-        <Flexbox gap={1} paddingBlock={1}>
-          {topics.map((topic) => (
-            <CronTopicItem key={topic.id} topic={topic} />
-          ))}
-        </Flexbox>
-      )}
-    </Flexbox>
-  );
-});
-
-export default CronTopicGroup;

package/src/app/[variants]/(main)/group/features/ChangelogModal.tsx

@@ -1,11 +0,0 @@
-import ChangelogModal from '@/features/ChangelogModal';
-import { ChangelogService } from '@/server/services/changelog';
-
-const Changelog = async () => {
-  const service = new ChangelogService();
-  const id = await service.getLatestChangelogId();
-
-  return <ChangelogModal currentId={id} />;
-};
-
-export default Changelog;

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

@@ -1,62 +0,0 @@
-import { type MenuProps } from '@lobehub/ui';
-import { useCallback } from 'react';
-
-import { useSessionItemMenuItems } from '../../../../hooks';
-
-interface ActionProps {
-  group: string | undefined;
-  id: string;
-  openCreateGroupModal: () => void;
-  parentType: 'agent' | 'group';
-  pinned: boolean;
-  sessionType?: string;
-  toggleEditing: (visible?: boolean) => void;
-}
-
-export const useDropdownMenu = ({
-  group,
-  id,
-  openCreateGroupModal,
-  parentType,
-  pinned,
-  sessionType,
-  toggleEditing,
-}: ActionProps): (() => MenuProps['items']) => {
-  const {
-    pinMenuItem,
-    renameMenuItem,
-    duplicateMenuItem,
-    openInNewWindowMenuItem,
-    moveToGroupMenuItem,
-    deleteMenuItem,
-  } = useSessionItemMenuItems();
-
-  return useCallback(
-    () =>
-      [
-        pinMenuItem(id, pinned, parentType),
-        renameMenuItem(toggleEditing),
-        duplicateMenuItem(id),
-        openInNewWindowMenuItem(id),
-        { type: 'divider' },
-        moveToGroupMenuItem(id, group, openCreateGroupModal),
-        { type: 'divider' },
-        deleteMenuItem(id, parentType, sessionType),
-      ].filter(Boolean) as MenuProps['items'],
-    [
-      id,
-      pinned,
-      parentType,
-      group,
-      sessionType,
-      pinMenuItem,
-      renameMenuItem,
-      duplicateMenuItem,
-      openInNewWindowMenuItem,
-      moveToGroupMenuItem,
-      deleteMenuItem,
-      openCreateGroupModal,
-      toggleEditing,
-    ],
-  );
-};