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

package/src/components/InlineRename/index.tsx

@@ -0,0 +1,121 @@
+'use client';
+
+import { Input, type InputProps, Popover } from '@lobehub/ui';
+import type { InputRef, PopoverProps } from 'antd';
+import { KeyboardEvent, memo, useCallback, useEffect, useRef, useState } from 'react';
+
+function FocusableInput(props: InputProps) {
+  const ref = useRef<InputRef>(null);
+  useEffect(() => {
+    queueMicrotask(() => {
+      ref.current?.input?.focus();
+    });
+  }, []);
+  return <Input {...props} ref={ref} />;
+}
+
+export interface InlineRenameProps {
+  /**
+   * Callback when editing is cancelled (Escape key)
+   */
+  onCancel?: () => void;
+  /**
+   * Callback when open state changes
+   */
+  onOpenChange: (open: boolean) => void;
+  /**
+   * Callback to save the new title
+   */
+  onSave: (newTitle: string) => void | Promise<void>;
+  /**
+   * Whether the popover is open (editing mode)
+   */
+  open: boolean;
+  /**
+   * Popover placement
+   */
+  placement?: PopoverProps['placement'];
+  /**
+   * Current title
+   */
+  title: string;
+  /**
+   * Popover width
+   */
+  width?: number;
+}
+
+const InlineRename = memo<InlineRenameProps>(
+  ({ open, title, onOpenChange, onSave, onCancel, placement = 'bottomLeft', width = 320 }) => {
+    const [newTitle, setNewTitle] = useState(title);
+    const savedRef = useRef(false);
+
+    // Reset state when opening
+    useEffect(() => {
+      if (open) {
+        setNewTitle(title);
+        savedRef.current = false;
+      }
+    }, [open, title]);
+
+    const handleSave = useCallback(async () => {
+      if (savedRef.current) return;
+
+      if (newTitle && title !== newTitle) {
+        savedRef.current = true;
+        await onSave(newTitle);
+      }
+    }, [newTitle, title, onSave]);
+
+    const handleClose = useCallback(() => {
+      onOpenChange(false);
+    }, [onOpenChange]);
+
+    const handleKeyDown = useCallback(
+      (e: KeyboardEvent) => {
+        if (e.key === 'Escape') {
+          e.preventDefault();
+          e.stopPropagation();
+          onCancel?.();
+          handleClose();
+        }
+      },
+      [onCancel, handleClose],
+    );
+
+    return (
+      <Popover
+        content={
+          <FocusableInput
+            defaultValue={title}
+            onBlur={handleSave}
+            onChange={(e) => setNewTitle(e.target.value)}
+            onClick={(e) => e.stopPropagation()}
+            onKeyDown={handleKeyDown}
+            onPressEnter={() => {
+              handleSave();
+              handleClose();
+            }}
+          />
+        }
+        onOpenChange={(nextOpen) => {
+          if (!nextOpen) handleSave();
+          onOpenChange(nextOpen);
+        }}
+        open={open}
+        placement={placement}
+        styles={{
+          content: {
+            padding: 4,
+            width,
+          },
+        }}
+        trigger="click"
+      >
+        <div />
+      </Popover>
+    );
+  },
+);
+
+export default InlineRename;

package/src/features/NavPanel/components/NavItem.tsx

@@ -98,7 +98,7 @@ const NavItem = memo<NavItemProps>(
 
         <Flexbox align={'center'} flex={1} gap={8} horizontal style={{ overflow: 'hidden' }}>
           <Text color={textColor} ellipsis style={{ flex: 1 }}>
-            {title || 'LobeHub'}
+            {title}
           </Text>
           <Flexbox
             align={'center'}

package/src/locales/default/setting.ts

@@ -33,6 +33,7 @@ export default {
   'agentCronJobs.maxExecutions': 'Max Executions',
   'agentCronJobs.name': 'Task Name',
   'agentCronJobs.never': 'Never',
+  'agentCronJobs.noExecutionResults': 'No execution results',
   'agentCronJobs.remainingExecutions': 'Remaining: {{count}}',
   'agentCronJobs.save': 'Save',
   'agentCronJobs.schedule': 'Schedule',
@@ -42,6 +43,7 @@ export default {
   'agentCronJobs.timeRange': 'Time Range',
   'agentCronJobs.title': 'Scheduled Tasks',
   'agentCronJobs.unlimited': 'Unlimited',
+  'agentCronJobs.unnamedTask': 'Unnamed Task',
   'agentCronJobs.updateSuccess': 'Scheduled task updated successfully',
   'agentCronJobs.weekdays': 'Weekdays',
   'agentInfoDescription.basic.avatar': 'Avatar',

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/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/hooks/useFetchCronTopicsWithJobInfo.ts

@@ -1,56 +0,0 @@
-import { ENABLE_BUSINESS_FEATURES } from '@lobechat/business-const';
-import useSWR from 'swr';
-
-import { lambdaClient } from '@/libs/trpc/client/lambda';
-import { useAgentStore } from '@/store/agent';
-
-/**
- * Fetch cron topics grouped by cronJob with job information
- */
-export const useFetchCronTopicsWithJobInfo = () => {
-  const agentId = useAgentStore((s) => s.activeAgentId);
-
-  const { data, isLoading, error, mutate } = useSWR(
-    ENABLE_BUSINESS_FEATURES && agentId ? ['cronTopicsWithJobInfo', agentId] : null,
-    async () => {
-      if (!agentId) return [];
-
-      const [cronJobsResult, cronTopicsGroups] = await Promise.all([
-        lambdaClient.agentCronJob.findByAgent.query({ agentId }),
-        lambdaClient.topic.getCronTopicsGroupedByCronJob.query({ agentId }),
-      ]);
-
-      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];
-    },
-    {
-      revalidateOnFocus: false,
-    },
-  );
-
-  return {
-    cronTopicsGroupsWithJobInfo: data || [],
-    error,
-    isLoading,
-    mutate,
-  };
-};