feat(#29): implement cron job configuration

- Add CronSchedule model to Prisma schema
- Implement CronService with CRUD operations
- Add REST API endpoints for cron management
- Create MoltBot plugin skill definition (SKILL.md)
- TDD: 9 passing tests for CronService

apps/api/src/cron/cron.service.spec.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { Test, TestingModule } from "@nestjs/testing";
+import { CronService } from "./cron.service";
+import { PrismaService } from "../prisma/prisma.service";
+
+describe("CronService", () => {
+  let service: CronService;
+  let prisma: PrismaService;
+
+  const mockPrisma = {
+    cronSchedule: {
+      create: vi.fn(),
+      findMany: vi.fn(),
+      findUnique: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn(),
+    },
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        CronService,
+        {
+          provide: PrismaService,
+          useValue: mockPrisma,
+        },
+      ],
+    }).compile();
+
+    service = module.get<CronService>(CronService);
+    prisma = module.get<PrismaService>(PrismaService);
+    vi.clearAllMocks();
+  });
+
+  it("should be defined", () => {
+    expect(service).toBeDefined();
+  });
+
+  describe("create", () => {
+    it("should create a cron schedule", async () => {
+      const createDto = {
+        workspaceId: "ws-123",
+        expression: "0 9 * * *",
+        command: "morning briefing",
+      };
+
+      const expectedSchedule = {
+        id: "cron-1",
+        ...createDto,
+        enabled: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      mockPrisma.cronSchedule.create.mockResolvedValue(expectedSchedule);
+
+      const result = await service.create(createDto);
+
+      expect(result).toEqual(expectedSchedule);
+      expect(mockPrisma.cronSchedule.create).toHaveBeenCalledWith({
+        data: {
+          workspaceId: createDto.workspaceId,
+          expression: createDto.expression,
+          command: createDto.command,
+          enabled: true,
+        },
+      });
+    });
+
+    it("should reject invalid cron expressions", async () => {
+      const createDto = {
+        workspaceId: "ws-123",
+        expression: "not-a-cron",
+        command: "test command",
+      };
+
+      await expect(service.create(createDto)).rejects.toThrow("Invalid cron expression");
+    });
+  });
+
+  describe("findAll", () => {
+    it("should return all schedules for a workspace", async () => {
+      const workspaceId = "ws-123";
+      const expectedSchedules = [
+        { id: "cron-1", workspaceId, expression: "0 9 * * *", command: "morning briefing", enabled: true },
+        { id: "cron-2", workspaceId, expression: "0 17 * * *", command: "evening summary", enabled: true },
+      ];
+
+      mockPrisma.cronSchedule.findMany.mockResolvedValue(expectedSchedules);
+
+      const result = await service.findAll(workspaceId);
+
+      expect(result).toEqual(expectedSchedules);
+      expect(mockPrisma.cronSchedule.findMany).toHaveBeenCalledWith({
+        where: { workspaceId },
+        orderBy: { createdAt: "desc" },
+      });
+    });
+  });
+
+  describe("findOne", () => {
+    it("should return a schedule by id", async () => {
+      const schedule = {
+        id: "cron-1",
+        workspaceId: "ws-123",
+        expression: "0 9 * * *",
+        command: "morning briefing",
+        enabled: true,
+      };
+
+      mockPrisma.cronSchedule.findUnique.mockResolvedValue(schedule);
+
+      const result = await service.findOne("cron-1", "ws-123");
+
+      expect(result).toEqual(schedule);
+      expect(mockPrisma.cronSchedule.findUnique).toHaveBeenCalledWith({
+        where: { id: "cron-1" },
+      });
+    });
+
+    it("should return null if schedule not found", async () => {
+      mockPrisma.cronSchedule.findUnique.mockResolvedValue(null);
+
+      const result = await service.findOne("cron-999", "ws-123");
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("update", () => {
+    it("should update a cron schedule", async () => {
+      const updateDto = { expression: "0 8 * * *", enabled: false };
+      const expectedSchedule = {
+        id: "cron-1",
+        workspaceId: "ws-123",
+        expression: "0 8 * * *",
+        command: "morning briefing",
+        enabled: false,
+      };
+
+      mockPrisma.cronSchedule.findUnique.mockResolvedValue({ id: "cron-1", workspaceId: "ws-123" });
+      mockPrisma.cronSchedule.update.mockResolvedValue(expectedSchedule);
+
+      const result = await service.update("cron-1", "ws-123", updateDto);
+
+      expect(result).toEqual(expectedSchedule);
+      expect(mockPrisma.cronSchedule.update).toHaveBeenCalled();
+    });
+  });
+
+  describe("remove", () => {
+    it("should delete a cron schedule", async () => {
+      const schedule = {
+        id: "cron-1",
+        workspaceId: "ws-123",
+        expression: "0 9 * * *",
+        command: "morning briefing",
+        enabled: true,
+      };
+
+      mockPrisma.cronSchedule.findUnique.mockResolvedValue(schedule);
+      mockPrisma.cronSchedule.delete.mockResolvedValue(schedule);
+
+      const result = await service.remove("cron-1", "ws-123");
+
+      expect(result).toEqual(schedule);
+      expect(mockPrisma.cronSchedule.delete).toHaveBeenCalledWith({
+        where: { id: "cron-1" },
+      });
+    });
+
+    it("should throw if schedule belongs to different workspace", async () => {
+      mockPrisma.cronSchedule.findUnique.mockResolvedValue({
+        id: "cron-1",
+        workspaceId: "ws-456",
+      });
+
+      await expect(service.remove("cron-1", "ws-123")).rejects.toThrow(
+        "Not authorized to delete this schedule"
+      );
+    });
+  });
+});