@lobehub/lobehub 2.0.0-next.251 → 2.0.0-next.253

package/src/app/[variants]/(main)/chat/profile/features/AgentCronJobs/index.tsx

@@ -0,0 +1,130 @@
+'use client';
+
+import { ENABLE_BUSINESS_FEATURES } from '@lobechat/business-const';
+import { Flexbox } from '@lobehub/ui';
+import { Modal, Typography } from 'antd';
+import { Clock } from 'lucide-react';
+import { memo, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { useAgentStore } from '@/store/agent';
+
+import CronJobCards from './CronJobCards';
+import CronJobForm from './CronJobForm';
+import { useAgentCronJobs } from './hooks/useAgentCronJobs';
+
+const { Title } = Typography;
+
+interface AgentCronJobsProps {
+  onFormModalChange?: (show: boolean) => void;
+  showFormModal?: boolean;
+}
+
+const AgentCronJobs = memo<AgentCronJobsProps>(({ showFormModal, onFormModalChange }) => {
+  const { t } = useTranslation('setting');
+  const agentId = useAgentStore((s) => s.activeAgentId);
+  const [internalShowForm, setInternalShowForm] = useState(false);
+  const [editingJob, setEditingJob] = useState<string | null>(null);
+  const [submitting, setSubmitting] = useState(false);
+  const formRef = useRef<any>(null);
+
+  // Use external control if provided, otherwise use internal state
+  const showForm = showFormModal ?? internalShowForm;
+  const setShowForm = onFormModalChange ?? setInternalShowForm;
+
+  const { cronJobs, loading, createCronJob, updateCronJob, deleteCronJob } =
+    useAgentCronJobs(agentId);
+
+  if (!ENABLE_BUSINESS_FEATURES) return null;
+
+  if (!agentId) {
+    return null;
+  }
+
+  const handleCreate = async (data: any) => {
+    setSubmitting(true);
+    try {
+      await createCronJob(data);
+      setShowForm(false);
+    } finally {
+      setSubmitting(false);
+    }
+  };
+
+  const handleEdit = (jobId: string) => {
+    setEditingJob(jobId);
+    setShowForm(true);
+  };
+
+  const handleUpdate = async (data: any) => {
+    if (editingJob) {
+      setSubmitting(true);
+      try {
+        await updateCronJob(editingJob, data);
+        setShowForm(false);
+        setEditingJob(null);
+      } finally {
+        setSubmitting(false);
+      }
+    }
+  };
+
+  const handleCancel = () => {
+    setShowForm(false);
+    setEditingJob(null);
+    formRef.current?.resetFields();
+  };
+
+  const handleModalOk = () => {
+    formRef.current?.submit();
+  };
+
+  const handleDelete = async (jobId: string) => {
+    await deleteCronJob(jobId);
+  };
+
+  const hasCronJobs = cronJobs && cronJobs.length > 0;
+
+  return (
+    <>
+      {/* Show cards section only if there are jobs */}
+      {hasCronJobs && (
+        <Flexbox gap={12} style={{ marginBottom: 16, marginTop: 16 }}>
+          <Title level={5} style={{ margin: 0 }}>
+            <Flexbox align="center" gap={8} horizontal>
+              <Clock size={16} />
+              {t('agentCronJobs.title')}
+            </Flexbox>
+          </Title>
+
+          <CronJobCards
+            cronJobs={cronJobs}
+            loading={loading}
+            onDelete={handleDelete}
+            onEdit={handleEdit}
+          />
+        </Flexbox>
+      )}
+
+      {/* Form Modal */}
+      <Modal
+        confirmLoading={submitting}
+        okText={editingJob ? t('agentCronJobs.save' as any) : t('agentCronJobs.create' as any)}
+        onCancel={handleCancel}
+        onOk={handleModalOk}
+        open={showForm}
+        title={editingJob ? t('agentCronJobs.editJob') : t('agentCronJobs.addJob')}
+        width={640}
+      >
+        <CronJobForm
+          editingJob={editingJob ? cronJobs?.find((job) => job.id === editingJob) : undefined}
+          formRef={formRef}
+          onCancel={handleCancel}
+          onSubmit={editingJob ? handleUpdate : handleCreate}
+        />
+      </Modal>
+    </>
+  );
+});
+
+export default AgentCronJobs;

package/src/app/[variants]/(main)/chat/profile/features/ProfileEditor/index.tsx

@@ -1,19 +1,22 @@
 'use client';
 
+import { ENABLE_BUSINESS_FEATURES } from '@lobechat/business-const';
 import { Button, Flexbox } from '@lobehub/ui';
-import { Divider } from 'antd';
+import { Divider, message } from 'antd';
 import isEqual from 'fast-deep-equal';
-import { PlayIcon } from 'lucide-react';
-import React, { memo } from 'react';
+import { Clock, PlayIcon } from 'lucide-react';
+import React, { memo, useCallback } from 'react';
 import { useTranslation } from 'react-i18next';
 import urlJoin from 'url-join';
 
 import ModelSelect from '@/features/ModelSelect';
 import { useQueryRoute } from '@/hooks/useQueryRoute';
+import { agentCronJobService } from '@/services/agentCronJob';
 import { useAgentStore } from '@/store/agent';
 import { agentSelectors } from '@/store/agent/selectors';
 import { useChatStore } from '@/store/chat';
 
+import AgentCronJobs from '../AgentCronJobs';
 import EditorCanvas from '../EditorCanvas';
 import AgentHeader from './AgentHeader';
 import AgentTool from './AgentTool';
@@ -26,6 +29,26 @@ const ProfileEditor = memo(() => {
   const switchTopic = useChatStore((s) => s.switchTopic);
   const router = useQueryRoute();
 
+  const handleCreateCronJob = useCallback(async () => {
+    if (!agentId) return;
+    try {
+      const result = await agentCronJobService.create({
+        agentId,
+        content: t('agentCronJobs.form.content.placeholder') || 'This is a cron job',
+        cronPattern: '0 */30 * * *',
+        enabled: true,
+        name: t('agentCronJobs.addJob') || 'Cron Job Task',
+      });
+
+      if (result.success) {
+        router.push(urlJoin('/agent', agentId, 'cron', result.data.id));
+      }
+    } catch (error) {
+      console.error('Failed to create cron job:', error);
+      message.error('Failed to create scheduled task');
+    }
+  }, [agentId, router, t]);
+
   return (
     <>
       <Flexbox
@@ -72,11 +95,18 @@ const ProfileEditor = memo(() => {
           >
             {t('startConversation')}
           </Button>
+          {ENABLE_BUSINESS_FEATURES && (
+            <Button icon={Clock} onClick={handleCreateCronJob}>
+              {t('agentCronJobs.addJob')}
+            </Button>
+          )}
         </Flexbox>
       </Flexbox>
       <Divider />
       {/* Main Content: Prompt Editor */}
       <EditorCanvas />
+      {/* Agent Cron Jobs Display (only show if jobs exist) */}
+      {ENABLE_BUSINESS_FEATURES && <AgentCronJobs />}
     </>
   );
 });

package/src/app/[variants]/router/desktopRouter.config.tsx

@@ -39,6 +39,13 @@ export const desktopRoutes: RouteConfig[] = [
                 ),
                 path: 'profile',
               },
+              {
+                element: dynamicElement(
+                  () => import('../(main)/chat/cron/[cronId]'),
+                  'Desktop > Chat > Cron Detail',
+                ),
+                path: 'cron/:cronId',
+              },
             ],
             element: <DesktopChatLayout />,
             errorElement: <ErrorBoundary resetPath="/agent" />,

package/src/features/ChatInput/ActionBar/Params/Controls.tsx

@@ -80,10 +80,10 @@ const ParamControlWrapper = memo<ParamControlWrapperProps>(
         <Checkbox
           checked={checked}
           className={styles.checkbox}
-          onChange={(v) => {
-            onToggle(v);
+          onClick={(e) => {
+            e.stopPropagation();
+            onToggle(!checked);
           }}
-          onClick={(e) => e.stopPropagation()}
         />
         <div style={{ flex: 1 }}>
           <Component disabled={disabled} onChange={onChange} value={value} />
@@ -275,6 +275,7 @@ const Controls = memo<ControlsProps>(({ setUpdating }) => {
           disabled={!enabled}
           onToggle={(checked) => handleToggle(key, checked)}
           styles={styles}
+          value={form.getFieldValue(PARAM_NAME_MAP[key])}
         />
       ),
       label: (
@@ -297,9 +298,9 @@ const Controls = memo<ControlsProps>(({ setUpdating }) => {
         mobile
           ? baseItems
           : baseItems.map(({ tag, ...item }) => ({
-              ...item,
-              desc: <Tag size={'small'}>{tag}</Tag>,
-            }))
+            ...item,
+            desc: <Tag size={'small'}>{tag}</Tag>,
+          }))
       }
       itemsType={'flat'}
       onValuesChange={handleValuesChange}

package/src/hooks/useFetchCronTopics.ts

@@ -0,0 +1,29 @@
+import useSWR from 'swr';
+
+import { lambdaClient } from '@/libs/trpc/client/lambda';
+import { useAgentStore } from '@/store/agent';
+
+/**
+ * Fetch cron topics grouped by cronJob for the current agent
+ */
+export const useFetchCronTopics = () => {
+  const agentId = useAgentStore((s) => s.activeAgentId);
+
+  const { data, isLoading, error, mutate } = useSWR(
+    agentId ? ['cronTopics', agentId] : null,
+    async () => {
+      if (!agentId) return [];
+      return await lambdaClient.topic.getCronTopicsGroupedByCronJob.query({ agentId });
+    },
+    {
+      revalidateOnFocus: false,
+    },
+  );
+
+  return {
+    cronTopicsGroups: data || [],
+    error,
+    isLoading,
+    mutate,
+  };
+};

package/src/hooks/useFetchCronTopicsWithJobInfo.ts

@@ -0,0 +1,56 @@
+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,
+  };
+};

package/src/hooks/useFetchTopics.ts

@@ -7,7 +7,7 @@ import { systemStatusSelectors } from '@/store/global/selectors';
 /**
  * Fetch topics for the current session (agent or group)
  */
-export const useFetchTopics = () => {
+export const useFetchTopics = (options?: { excludeTriggers?: string[] }) => {
   const isInbox = useAgentStore(builtinAgentSelectors.isInboxAgent);
   const [activeAgentId, activeGroupId, useFetchTopicsHook] = useChatStore((s) => [
     s.activeAgentId,
@@ -20,6 +20,9 @@ export const useFetchTopics = () => {
   // If in group session, use groupId; otherwise use agentId
   const { isValidating, data } = useFetchTopicsHook(true, {
     agentId: activeAgentId,
+    ...(options?.excludeTriggers && options.excludeTriggers.length > 0
+      ? { excludeTriggers: options.excludeTriggers }
+      : {}),
     groupId: activeGroupId,
     isInbox: activeGroupId ? false : isInbox,
     pageSize: topicPageSize,

package/src/locales/default/setting.ts

@@ -2,11 +2,54 @@ export default {
   '_cloud.officialProvider': '{{name}} Official Model Service',
   'about.title': 'About',
   'advancedSettings': 'Advanced Settings',
+  'agentCronJobs.addJob': 'Add Scheduled Task',
+  'agentCronJobs.confirmDelete': 'Are you sure you want to delete this scheduled task?',
+  'agentCronJobs.content': 'Task Content',
+  'agentCronJobs.create': 'Create',
+  'agentCronJobs.createSuccess': 'Scheduled task created successfully',
+  'agentCronJobs.deleteJob': 'Delete Task',
+  'agentCronJobs.deleteSuccess': 'Scheduled task deleted successfully',
+  'agentCronJobs.description': 'Automate your agent with scheduled executions',
+  'agentCronJobs.disable': 'Disable',
+  'agentCronJobs.editJob': 'Edit Scheduled Task',
+  'agentCronJobs.empty.description': 'Create your first scheduled task to automate your agent',
+  'agentCronJobs.empty.title': 'No scheduled tasks yet',
+  'agentCronJobs.enable': 'Enable',
+  'agentCronJobs.form.content.placeholder': 'Enter the prompt or instruction for the agent',
+  'agentCronJobs.form.maxExecutions.placeholder': 'Leave empty for unlimited',
+  'agentCronJobs.form.name.placeholder': 'Enter task name',
+  'agentCronJobs.form.timeRange.end': 'End Time',
+  'agentCronJobs.form.timeRange.start': 'Start Time',
+  'agentCronJobs.form.validation.contentRequired': 'Task content is required',
+  'agentCronJobs.form.validation.invalidTimeRange': 'Start time must be before end time',
+  'agentCronJobs.form.validation.nameRequired': 'Task name is required',
+  'agentCronJobs.interval.12hours': 'Every 12 hours',
+  'agentCronJobs.interval.1hour': 'Every hour',
+  'agentCronJobs.interval.30min': 'Every 30 minutes',
+  'agentCronJobs.interval.6hours': 'Every 6 hours',
+  'agentCronJobs.interval.daily': 'Daily',
+  'agentCronJobs.interval.weekly': 'Weekly',
+  'agentCronJobs.lastExecuted': 'Last Executed',
+  'agentCronJobs.maxExecutions': 'Max Executions',
+  'agentCronJobs.name': 'Task Name',
+  'agentCronJobs.never': 'Never',
+  'agentCronJobs.remainingExecutions': 'Remaining: {{count}}',
+  'agentCronJobs.save': 'Save',
+  'agentCronJobs.schedule': 'Schedule',
+  'agentCronJobs.status.depleted': 'Depleted',
+  'agentCronJobs.status.disabled': 'Disabled',
+  'agentCronJobs.status.enabled': 'Enabled',
+  'agentCronJobs.timeRange': 'Time Range',
+  'agentCronJobs.title': 'Scheduled Tasks',
+  'agentCronJobs.unlimited': 'Unlimited',
+  'agentCronJobs.updateSuccess': 'Scheduled task updated successfully',
+  'agentCronJobs.weekdays': 'Weekdays',
   'agentInfoDescription.basic.avatar': 'Avatar',
   'agentInfoDescription.basic.description': 'Description',
   'agentInfoDescription.basic.name': 'Name',
   'agentInfoDescription.basic.tags': 'Tags',
   'agentInfoDescription.basic.title': 'Agent info',
+
   'agentInfoDescription.chat.enableHistoryCount': 'Enable Message History Count',
   'agentInfoDescription.chat.historyCount': 'Message History Count',
   'agentInfoDescription.chat.no': 'No',
@@ -47,7 +90,7 @@ export default {
   'danger.reset.action': 'Reset Now',
   'danger.reset.confirm': 'Reset all settings?',
   'danger.reset.currentVersion': 'Current Version',
-  'danger.reset.desc': 'Restore all settings to defaults. Your data won’t be deleted.',
+  'danger.reset.desc': 'Restore all settings to defaults. Your data wont be deleted.',
   'danger.reset.success': 'All settings have been reset',
   'danger.reset.title': 'Reset All Settings',
   'defaultAgent.model.desc': 'Default model used when creating a new Agent',