@lobehub/lobehub 2.0.0-next.250 → 2.0.0-next.252

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

@@ -0,0 +1,367 @@
+import { TRPCError } from '@trpc/server';
+import { z } from 'zod';
+
+import { AgentCronJobModel } from '@/database/models/agentCronJob';
+import {
+  type CreateAgentCronJobData,
+  type UpdateAgentCronJobData,
+  insertAgentCronJobSchema,
+  updateAgentCronJobSchema,
+} from '@/database/schemas/agentCronJob';
+import { authedProcedure, router } from '@/libs/trpc/lambda';
+import { serverDatabase } from '@/libs/trpc/lambda/middleware';
+
+const agentCronJobProcedure = authedProcedure.use(serverDatabase);
+
+const listQuerySchema = z.object({
+  agentId: z.string().optional(),
+  enabled: z.boolean().optional(),
+  limit: z.number().min(1).max(100).default(20),
+  offset: z.number().min(0).default(0),
+});
+
+const resetExecutionsSchema = z.object({
+  id: z.string(),
+  newMaxExecutions: z.number().min(1).max(10_000).optional(),
+});
+
+const batchUpdateStatusSchema = z.object({
+  enabled: z.boolean(),
+  ids: z.array(z.string()),
+});
+
+// Create input schema for tRPC that omits server-managed fields
+const createAgentCronJobInputSchema = insertAgentCronJobSchema.omit({
+  userId: true, // Provided by authentication context
+});
+
+/**
+ * Agent Cron Job tRPC Router
+ *
+ * Provides type-safe API for managing agent scheduled tasks
+ */
+export const agentCronJobRouter = router({
+  /**
+   * Batch update status (enable/disable) for multiple jobs
+   */
+  batchUpdateStatus: agentCronJobProcedure
+    .input(batchUpdateStatusSchema)
+    .mutation(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { ids, enabled } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const updatedCount = await cronJobModel.batchUpdateStatus(ids, enabled);
+
+        return {
+          data: { updatedCount },
+          message: `${updatedCount} cron jobs ${enabled ? 'enabled' : 'disabled'} successfully`,
+          success: true,
+        };
+      } catch (error) {
+        console.error('[agentCronJob:batchUpdateStatus]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to update cron job statuses',
+        });
+      }
+    }),
+
+  /**
+   * Create a new cron job
+   */
+  create: agentCronJobProcedure
+    .input(createAgentCronJobInputSchema)
+    .mutation(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        // Add userId to the input data since it's provided by authentication context
+        const cronJobData = { ...input, userId };
+        const cronJob = await cronJobModel.create(cronJobData as CreateAgentCronJobData);
+
+        return {
+          data: cronJob,
+          message: 'Cron job created successfully',
+          success: true,
+        };
+      } catch (error) {
+        console.error('[agentCronJob:create]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to create cron job',
+        });
+      }
+    }),
+
+  /**
+   * Delete a cron job
+   */
+  delete: agentCronJobProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { id } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const deleted = await cronJobModel.delete(id);
+
+        if (!deleted) {
+          throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: 'Cron job not found or access denied',
+          });
+        }
+
+        return {
+          message: 'Cron job deleted successfully',
+          success: true,
+        };
+      } catch (error) {
+        if (error instanceof TRPCError) throw error;
+
+        console.error('[agentCronJob:delete]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to delete cron job',
+        });
+      }
+    }),
+
+  /**
+   * List cron jobs by agent ID
+   */
+  findByAgent: agentCronJobProcedure
+    .input(z.object({ agentId: z.string() }))
+    .query(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { agentId } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const cronJobs = await cronJobModel.findByAgentId(agentId);
+
+        return {
+          data: cronJobs,
+          success: true,
+        };
+      } catch (error) {
+        console.error('[agentCronJob:findByAgent]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to fetch agent cron jobs',
+        });
+      }
+    }),
+
+  /**
+   * Get a single cron job by ID
+   */
+  findById: agentCronJobProcedure
+    .input(z.object({ id: z.string() }))
+    .query(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { id } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const cronJob = await cronJobModel.findById(id);
+
+        if (!cronJob) {
+          throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: 'Cron job not found',
+          });
+        }
+
+        return {
+          data: cronJob,
+          success: true,
+        };
+      } catch (error) {
+        if (error instanceof TRPCError) throw error;
+
+        console.error('[agentCronJob:findById]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to fetch cron job',
+        });
+      }
+    }),
+
+  /**
+   * Get jobs that are near depletion (for warnings)
+   */
+  getNearDepletion: agentCronJobProcedure
+    .input(z.object({ threshold: z.number().min(1).max(20).default(5) }))
+    .query(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { threshold } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const jobs = await cronJobModel.getTasksNearDepletion(threshold);
+
+        return {
+          data: jobs,
+          success: true,
+        };
+      } catch (error) {
+        console.error('[agentCronJob:getNearDepletion]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to fetch near depletion jobs',
+        });
+      }
+    }),
+
+  /**
+   * Get execution statistics for user's cron jobs
+   */
+  getStats: agentCronJobProcedure.query(async ({ ctx }) => {
+    const { userId, serverDB: db } = ctx;
+
+    try {
+      const cronJobModel = new AgentCronJobModel(db, userId);
+      const stats = await cronJobModel.getExecutionStats();
+
+      return {
+        data: stats,
+        success: true,
+      };
+    } catch (error) {
+      console.error('[agentCronJob:getStats]', error);
+      throw new TRPCError({
+        cause: error,
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Failed to fetch execution statistics',
+      });
+    }
+  }),
+
+  /**
+   * List cron jobs with filtering and pagination
+   */
+  list: agentCronJobProcedure.input(listQuerySchema).query(async ({ input, ctx }) => {
+    const { userId, serverDB: db } = ctx;
+    const { agentId, enabled, limit, offset } = input;
+
+    try {
+      const cronJobModel = new AgentCronJobModel(db, userId);
+      const result = await cronJobModel.findWithPagination({
+        agentId,
+        enabled,
+        limit,
+        offset,
+      });
+
+      return {
+        data: result.jobs,
+        pagination: {
+          hasMore: offset + limit < result.total,
+          limit,
+          offset,
+          total: result.total,
+        },
+        success: true,
+      };
+    } catch (error) {
+      console.error('[agentCronJob:list]', error);
+      throw new TRPCError({
+        cause: error,
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Failed to fetch cron jobs',
+      });
+    }
+  }),
+
+  /**
+   * Reset execution counts for a cron job
+   */
+  resetExecutions: agentCronJobProcedure
+    .input(resetExecutionsSchema)
+    .mutation(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { id, newMaxExecutions } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const cronJob = await cronJobModel.resetExecutions(id, newMaxExecutions);
+
+        if (!cronJob) {
+          throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: 'Cron job not found or access denied',
+          });
+        }
+
+        return {
+          data: cronJob,
+          message: 'Execution counts reset successfully',
+          success: true,
+        };
+      } catch (error) {
+        if (error instanceof TRPCError) throw error;
+
+        console.error('[agentCronJob:resetExecutions]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to reset execution counts',
+        });
+      }
+    }),
+
+  /**
+   * Update a cron job
+   */
+  update: agentCronJobProcedure
+    .input(
+      z.object({
+        data: updateAgentCronJobSchema,
+        id: z.string(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { id, data } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const cronJob = await cronJobModel.update(id, data as UpdateAgentCronJobData);
+
+        if (!cronJob) {
+          throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: 'Cron job not found or access denied',
+          });
+        }
+
+        return {
+          data: cronJob,
+          message: 'Cron job updated successfully',
+          success: true,
+        };
+      } catch (error) {
+        if (error instanceof TRPCError) throw error;
+
+        console.error('[agentCronJob:update]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to update cron job',
+        });
+      }
+    }),
+
+  // Note: testExecution moved to cloud layer since it uses AgentCronWorkflow
+});

package/src/server/routers/lambda/image/index.test.ts

@@ -2,6 +2,8 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { AsyncTaskStatus, AsyncTaskType } from '@/types/asyncTask';
 
+import { imageRouter } from './index';
+
 // Use vi.hoisted for variables used in vi.mock factory
 const {
   mockServerDB,
@@ -79,8 +81,6 @@ vi.mock('@/utils/number', () => ({
   generateUniqueSeeds: vi.fn((count: number) => Array.from({ length: count }, (_, i) => 1000 + i)),
 }));
 
-import { imageRouter } from './index';
-
 describe('imageRouter', () => {
   const mockUserId = 'test-user-id';
   const mockAsyncCallerCreateImage = vi.fn();

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

@@ -8,6 +8,7 @@ import { topUpRouter } from '@/business/server/lambda-routers/topUp';
 import { publicProcedure, router } from '@/libs/trpc/lambda';
 
 import { agentRouter } from './agent';
+import { agentCronJobRouter } from './agentCronJob';
 import { agentGroupRouter } from './agentGroup';
 import { aiAgentRouter } from './aiAgent';
 import { aiChatRouter } from './aiChat';
@@ -46,6 +47,7 @@ import { userMemoryRouter } from './userMemory';
 
 export const lambdaRouter = router({
   agent: agentRouter,
+  agentCronJob: agentCronJobRouter,
   aiAgent: aiAgentRouter,
   aiChat: aiChatRouter,
   aiModel: aiModelRouter,

package/src/server/routers/lambda/market/index.ts

@@ -167,7 +167,7 @@ export const marketRouter = router({
     }),
 
   // ============================== MCP Market ==============================
-  getMcpCategories: marketProcedure
+getMcpCategories: marketProcedure
     .input(
       z
         .object({
@@ -351,7 +351,7 @@ export const marketRouter = router({
     }),
 
   // ============================== Plugin Market ==============================
-  getPluginCategories: marketProcedure
+getPluginCategories: marketProcedure
     .input(
       z
         .object({
@@ -439,7 +439,7 @@ export const marketRouter = router({
     }),
 
   // ============================== Providers ==============================
-  getProviderDetail: marketProcedure
+getProviderDetail: marketProcedure
     .input(
       z.object({
         identifier: z.string(),
@@ -503,7 +503,7 @@ export const marketRouter = router({
     }),
 
   // ============================== User Profile ==============================
-  getUserInfo: marketProcedure
+getUserInfo: marketProcedure
     .input(
       z.object({
         locale: z.string().optional(),
@@ -598,6 +598,26 @@ export const marketRouter = router({
       }
     }),
 
+  reportAgentEvent: marketProcedure
+    .input(
+      z.object({
+        event: z.enum(['add', 'chat', 'click']),
+        identifier: z.string(),
+        source: z.string().optional(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      log('createAgentEvent input: %O', input);
+
+      try {
+        await ctx.discoverService.createAgentEvent(input);
+        return { success: true };
+      } catch (error) {
+        console.error('Error reporting Agent event: %O', error);
+        return { success: false };
+      }
+    }),
+
   reportAgentInstall: marketProcedure
     .input(
       z.object({
@@ -655,6 +675,27 @@ export const marketRouter = router({
       }
     }),
 
+
+  reportMcpEvent: marketProcedure
+    .input(
+      z.object({
+        event: z.enum(['click', 'install', 'activate', 'uninstall']),
+        identifier: z.string(),
+        source: z.string().optional(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      log('createMcpEvent input: %O', input);
+
+      try {
+        await ctx.discoverService.createPluginEvent(input);
+        return { success: true };
+      } catch (error) {
+        console.error('Error reporting MCP event: %O', error);
+        return { success: false };
+      }
+    }),
+
   reportMcpInstallResult: marketProcedure
     .input(
       z.object({

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

@@ -142,11 +142,18 @@ export const topicRouter = router({
     return ctx.topicModel.queryAll();
   }),
 
+  getCronTopicsGroupedByCronJob: topicProcedure
+    .input(z.object({ agentId: z.string() }))
+    .query(async ({ input, ctx }) => {
+      return ctx.topicModel.getCronTopicsGroupedByCronJob(input.agentId);
+    }),
+
   getTopics: topicProcedure
     .input(
       z.object({
         agentId: z.string().nullable().optional(),
         current: z.number().optional(),
+        excludeTriggers: z.array(z.string()).optional(),
         groupId: z.string().nullable().optional(),
         isInbox: z.boolean().optional(),
         pageSize: z.number().optional(),
@@ -154,11 +161,11 @@ export const topicRouter = router({
       }),
     )
     .query(async ({ input, ctx }) => {
-      const { sessionId, isInbox, groupId, ...rest } = input;
+      const { sessionId, isInbox, groupId, excludeTriggers, ...rest } = input;
 
       // If groupId is provided, query by groupId directly
       if (groupId) {
-        const result = await ctx.topicModel.query({ groupId, ...rest });
+        const result = await ctx.topicModel.query({ excludeTriggers, groupId, ...rest });
         return { items: result.items, total: result.total };
       }
 
@@ -168,7 +175,12 @@ export const topicRouter = router({
         effectiveAgentId = await resolveAgentIdFromSession(sessionId, ctx.serverDB, ctx.userId);
       }
 
-      const result = await ctx.topicModel.query({ ...rest, agentId: effectiveAgentId, isInbox });
+      const result = await ctx.topicModel.query({
+        ...rest,
+        agentId: effectiveAgentId,
+        excludeTriggers,
+        isInbox,
+      });
 
       // Runtime migration: backfill agentId for ALL legacy topics and messages under this agent
       const runMigration = async () => {

package/src/server/services/aiAgent/index.ts

@@ -33,8 +33,12 @@ const log = debug('lobe-server:ai-agent-service');
  * This extends the public ExecAgentParams with server-side only options
  */
 interface InternalExecAgentParams extends ExecAgentParams {
+  /** Cron job ID that triggered this execution (if trigger is 'cron') */
+  cronJobId?: string;
   /** Step lifecycle callbacks for operation tracking (server-side only) */
   stepCallbacks?: StepLifecycleCallbacks;
+  /** Topic creation trigger source ('cron' | 'chat' | 'api') */
+  trigger?: string;
 }
 
 /**
@@ -88,6 +92,8 @@ export class AiAgentService {
       autoStart = true,
       existingMessageIds = [],
       stepCallbacks,
+      trigger,
+      cronJobId,
     } = params;
 
     // Validate that either agentId or slug is provided
@@ -114,12 +120,22 @@ export class AiAgentService {
     // 2. Handle topic creation: if no topicId provided, create a new topic; otherwise reuse existing
     let topicId = appContext?.topicId;
     if (!topicId) {
+      // Prepare metadata with cronJobId if provided
+      const metadata = cronJobId ? { cronJobId } : undefined;
+
       const newTopic = await this.topicModel.create({
         agentId: resolvedAgentId,
+        metadata,
         title: prompt.slice(0, 50) + (prompt.length > 50 ? '...' : ''),
+        trigger,
       });
       topicId = newTopic.id;
-      log('execAgent: created new topic %s', topicId);
+      log(
+        'execAgent: created new topic %s with trigger %s, cronJobId %s',
+        topicId,
+        trigger || 'default',
+        cronJobId || 'none',
+      );
     } else {
       log('execAgent: reusing existing topic %s', topicId);
     }
@@ -397,6 +413,7 @@ export class AiAgentService {
         groupId,
         messages: newTopic?.topicMessageIds,
         title: topicTitle,
+        // Note: execGroupAgent doesn't have trigger param yet, defaults to null
       });
       topicId = topicItem.id;
       isCreateNewTopic = true;

package/src/server/services/discover/index.ts

@@ -25,13 +25,15 @@ import {
   type DiscoverProviderItem,
   type DiscoverUserProfile,
   type IdentifiersResponse,
+  McpCategory,
   type McpListResponse,
   type McpQueryParams,
+  McpSorts,
   type ModelListResponse,
   type ModelQueryParams,
   ModelSorts,
   type PluginListResponse,
-  type PluginQueryParams,
+  type PluginQueryParams as PluginQueryParams,
   PluginSorts,
   type ProviderListResponse,
   type ProviderQueryParams,
@@ -48,7 +50,12 @@ import {
   MarketSDK,
   type UserInfoResponse,
 } from '@lobehub/market-sdk';
-import { type CallReportRequest, type InstallReportRequest } from '@lobehub/market-types';
+import {
+  AgentEventRequest,
+  type CallReportRequest,
+  type InstallReportRequest,
+  type PluginEventRequest,
+} from '@lobehub/market-types';
 import dayjs from 'dayjs';
 import debug from 'debug';
 import { cloneDeep, countBy, isString, merge, uniq, uniqBy } from 'es-toolkit/compat';
@@ -850,12 +857,16 @@ export class DiscoverService {
 
   getMcpList = async (params: McpQueryParams = {}): Promise<McpListResponse> => {
     log('getMcpList: params=%O', params);
-    const { locale } = params;
+    const { category, locale, sort } = params;
     const normalizedLocale = normalizeLocale(locale);
+    const isDiscoverCategory = category === McpCategory.Discover;
+
     const result = await this.market.plugins.getPluginList(
       {
         ...params,
+        category: isDiscoverCategory ? undefined : category,
         locale: normalizedLocale,
+        sort: isDiscoverCategory ? McpSorts.Recommended : sort,
       },
       {
         next: {
@@ -897,6 +908,21 @@ export class DiscoverService {
     await this.market.plugins.reportInstallation(params);
   };
 
+  /**
+   * record Agent plugin event
+   */
+  createAgentEvent = async (params: AgentEventRequest) => {
+    await this.market.agents.createEvent(params);
+  };
+
+  /**
+   * record MCP plugin event
+   */
+  createPluginEvent = async (params: PluginEventRequest) => {
+    await this.market.plugins.createEvent(params);
+  };
+
+
   /**
    * report plugin call result to marketplace
    */