feat: add CalDAV synchronization with automatic sync

- Add CaldavService with tsdav/ical.js for CalDAV server communication
- Add CaldavController, CaldavRepository, and caldav routes
- Add client-side CaldavConfigService with sync(), config CRUD
- Add CalDAV settings UI with config load/save in settings screen
- Sync on login, auto-login (AuthGuard), periodic timer (calendar), and sync button
- Push single events to CalDAV on server-side create/update/delete
- Push all events to CalDAV after chat event confirmation
- Refactor ChatService to use EventService instead of direct EventRepository
- Rename CalDav/calDav to Caldav/caldav for consistent naming
- Add Radicale Docker setup for local CalDAV testing
- Update PlantUML diagrams and CLAUDE.md with CalDAV architecture

apps/server/src/ai/utils/eventFormatter.ts

@@ -1,4 +0,0 @@
-import { formatDate, formatTime, formatDateTime } from "@calchat/shared";
-
-// Re-export from shared package for use in toolExecutor
-export { formatDate, formatTime, formatDateTime };

apps/server/src/ai/utils/index.ts

@@ -1,4 +1,3 @@
-export { formatDate, formatTime, formatDateTime } from "./eventFormatter";
 export { buildSystemPrompt } from "./systemPrompt";
 export {
   TOOL_DEFINITIONS,

apps/server/src/ai/utils/toolExecutor.ts

@@ -6,7 +6,7 @@ import {
   RecurringDeleteMode,
 } from "@calchat/shared";
 import { AIContext } from "../../services/interfaces";
-import { formatDate, formatTime, formatDateTime } from "./eventFormatter";
+import { formatDate, formatTime, formatDateTime } from "@calchat/shared";
 
 /**
  * Check if two time ranges overlap.

apps/server/src/app.ts

@@ -17,6 +17,9 @@ import {
 } from "./repositories";
 import { GPTAdapter } from "./ai";
 import { logger } from "./logging";
+import { MongoCaldavRepository } from "./repositories/mongo/MongoCaldavRepository";
+import { CaldavService } from "./services/CaldavService";
+import { CaldavController } from "./controllers/CaldavController";
 
 const app = express();
 const port = process.env.PORT || 3000;
@@ -51,6 +54,7 @@ if (process.env.NODE_ENV !== "production") {
 const userRepo = new MongoUserRepository();
 const eventRepo = new MongoEventRepository();
 const chatRepo = new MongoChatRepository();
+const caldavRepo = new MongoCaldavRepository();
 
 // Initialize AI provider
 const aiProvider = new GPTAdapter();
@@ -60,15 +64,16 @@ const authService = new AuthService(userRepo);
 const eventService = new EventService(eventRepo);
 const chatService = new ChatService(
   chatRepo,
-  eventRepo,
   eventService,
   aiProvider,
 );
+const caldavService = new CaldavService(caldavRepo, eventService);
 
 // Initialize controllers
 const authController = new AuthController(authService);
-const chatController = new ChatController(chatService);
-const eventController = new EventController(eventService);
+const chatController = new ChatController(chatService, caldavService);
+const eventController = new EventController(eventService, caldavService);
+const caldavController = new CaldavController(caldavService);
 
 // Setup routes
 app.use(
@@ -77,6 +82,7 @@ app.use(
     authController,
     chatController,
     eventController,
+    caldavController
   }),
 );
 

apps/server/src/controllers/CaldavController.ts

@@ -0,0 +1,85 @@
+import { Response } from "express";
+import { createLogger } from "../logging/logger";
+import { AuthenticatedRequest } from "./AuthMiddleware";
+import { CaldavConfig } from "@calchat/shared";
+import { CaldavService } from "../services/CaldavService";
+
+const log = createLogger("CaldavController");
+
+export class CaldavController {
+  constructor(private caldavService: CaldavService) {}
+
+  async saveConfig(req: AuthenticatedRequest, res: Response): Promise<void> {
+    try {
+      const config: CaldavConfig = { userId: req.user!.userId, ...req.body };
+      const response = await this.caldavService.saveConfig(config);
+      res.json(response);
+    } catch (error) {
+      log.error({ error, userId: req.user?.userId }, "Error saving config");
+      res.status(500).json({ error: "Failed to save config" });
+    }
+  }
+
+  async loadConfig(req: AuthenticatedRequest, res: Response): Promise<void> {
+    try {
+      const config = await this.caldavService.getConfig(req.user!.userId);
+      if (!config) {
+        res.status(404).json({ error: "No CalDAV config found" });
+        return;
+      }
+      // Don't expose the password to the client
+      res.json(config);
+    } catch (error) {
+      log.error({ error, userId: req.user?.userId }, "Error loading config");
+      res.status(500).json({ error: "Failed to load config" });
+    }
+  }
+
+  async deleteConfig(req: AuthenticatedRequest, res: Response): Promise<void> {
+    try {
+      await this.caldavService.deleteConfig(req.user!.userId);
+      res.status(204).send();
+    } catch (error) {
+      log.error({ error, userId: req.user?.userId }, "Error deleting config");
+      res.status(500).json({ error: "Failed to delete config" });
+    }
+  }
+
+  async pullEvents(req: AuthenticatedRequest, res: Response): Promise<void> {
+    try {
+      const events = await this.caldavService.pullEvents(req.user!.userId);
+      res.json(events);
+    } catch (error) {
+      log.error({ error, userId: req.user?.userId }, "Error pulling events");
+      res.status(500).json({ error: "Failed to pull events" });
+    }
+  }
+
+  async pushEvents(req: AuthenticatedRequest, res: Response): Promise<void> {
+    try {
+      await this.caldavService.pushAll(req.user!.userId);
+      res.status(204).send();
+    } catch (error) {
+      log.error({ error, userId: req.user?.userId }, "Error pushing events");
+      res.status(500).json({ error: "Failed to push events" });
+    }
+  }
+
+  async pushEvent(req: AuthenticatedRequest, res: Response): Promise<void> {
+    try {
+      const event = await this.caldavService.findEventByCaldavUUID(
+        req.user!.userId,
+        req.params.caldavUUID,
+      );
+      if (!event) {
+        res.status(404).json({ error: "Event not found" });
+        return;
+      }
+      await this.caldavService.pushEvent(req.user!.userId, event);
+      res.status(204).send();
+    } catch (error) {
+      log.error({ error, userId: req.user?.userId }, "Error pushing event");
+      res.status(500).json({ error: "Failed to push event" });
+    }
+  }
+}

apps/server/src/controllers/ChatController.ts

@@ -8,13 +8,17 @@ import {
   RecurringDeleteMode,
 } from "@calchat/shared";
 import { ChatService } from "../services";
+import { CaldavService } from "../services/CaldavService";
 import { createLogger } from "../logging";
 import { AuthenticatedRequest } from "./AuthMiddleware";
 
 const log = createLogger("ChatController");
 
 export class ChatController {
-  constructor(private chatService: ChatService) {}
+  constructor(
+    private chatService: ChatService,
+    private caldavService: CaldavService,
+  ) {}
 
   async sendMessage(req: AuthenticatedRequest, res: Response): Promise<void> {
     try {
@@ -68,6 +72,16 @@ export class ChatController {
         deleteMode,
         occurrenceDate,
       );
+
+      // Sync confirmed event to CalDAV
+      try {
+        if (await this.caldavService.getConfig(userId)) {
+          await this.caldavService.pushAll(userId);
+        }
+      } catch (error) {
+        log.error({ error, userId }, "CalDAV push after confirm failed");
+      }
+
       res.json(response);
     } catch (error) {
       log.error(

apps/server/src/controllers/EventController.ts

@@ -1,17 +1,43 @@
 import { Response } from "express";
-import { RecurringDeleteMode } from "@calchat/shared";
+import { CalendarEvent, RecurringDeleteMode } from "@calchat/shared";
 import { EventService } from "../services";
 import { createLogger } from "../logging";
 import { AuthenticatedRequest } from "./AuthMiddleware";
+import { CaldavService } from "../services/CaldavService";
 
 const log = createLogger("EventController");
 
 export class EventController {
-  constructor(private eventService: EventService) {}
+  constructor(
+    private eventService: EventService,
+    private caldavService: CaldavService,
+  ) {}
+
+  private async pushToCaldav(userId: string, event: CalendarEvent) {
+    if (await this.caldavService.getConfig(userId)) {
+      try {
+        await this.caldavService.pushEvent(userId, event);
+      } catch (error) {
+        log.error({ error, userId }, "Error pushing event to CalDAV");
+      }
+    }
+  }
+
+  private async deleteFromCaldav(userId: string, event: CalendarEvent) {
+    if (event.caldavUUID && (await this.caldavService.getConfig(userId))) {
+      try {
+        await this.caldavService.deleteEvent(userId, event.caldavUUID);
+      } catch (error) {
+        log.error({ error, userId }, "Error deleting event from CalDAV");
+      }
+    }
+  }
 
   async create(req: AuthenticatedRequest, res: Response): Promise<void> {
     try {
-      const event = await this.eventService.create(req.user!.userId, req.body);
+      const userId = req.user!.userId;
+      const event = await this.eventService.create(userId, req.body);
+      await this.pushToCaldav(userId, event);
       res.status(201).json(event);
     } catch (error) {
       log.error({ error, userId: req.user?.userId }, "Error creating event");
@@ -83,15 +109,19 @@ export class EventController {
 
   async update(req: AuthenticatedRequest, res: Response): Promise<void> {
     try {
+      const userId = req.user!.userId;
       const event = await this.eventService.update(
         req.params.id,
-        req.user!.userId,
+        userId,
         req.body,
       );
       if (!event) {
         res.status(404).json({ error: "Event not found" });
         return;
       }
+
+      await this.pushToCaldav(userId, event);
+
       res.json(event);
     } catch (error) {
       log.error({ error, eventId: req.params.id }, "Error updating event");
@@ -101,46 +131,44 @@ export class EventController {
 
   async delete(req: AuthenticatedRequest, res: Response): Promise<void> {
     try {
+      const userId = req.user!.userId;
       const { mode, occurrenceDate } = req.query as {
         mode?: RecurringDeleteMode;
         occurrenceDate?: string;
       };
 
+      // Fetch event before deletion to get caldavUUID for sync
+      const event = await this.eventService.getById(req.params.id, userId);
+      if (!event) {
+        res.status(404).json({ error: "Event not found" });
+        return;
+      }
+
       // If mode is specified, use deleteRecurring
       if (mode) {
         const result = await this.eventService.deleteRecurring(
           req.params.id,
-          req.user!.userId,
+          userId,
           mode,
           occurrenceDate,
         );
 
-        // For 'all' mode or when event was completely deleted, return 204
-        if (result === null && mode === "all") {
-          res.status(204).send();
-          return;
-        }
-
-        // For 'single' or 'future' modes, return updated event
+        // Event was updated (single/future mode) - push update to CalDAV
         if (result) {
+          await this.pushToCaldav(userId, result);
           res.json(result);
           return;
         }
 
-        // result is null but mode wasn't 'all' - event not found or was deleted
+        // Event was fully deleted (all mode, or future from first occurrence)
+        await this.deleteFromCaldav(userId, event);
         res.status(204).send();
         return;
       }
 
       // Default behavior: delete completely
-      const deleted = await this.eventService.delete(
-        req.params.id,
-        req.user!.userId,
-      );
-      if (!deleted) {
-        res.status(404).json({ error: "Event not found" });
-        return;
-      }
+      await this.eventService.delete(req.params.id, userId);
+      await this.deleteFromCaldav(userId, event);
       res.status(204).send();
     } catch (error) {
       log.error({ error, eventId: req.params.id }, "Error deleting event");

apps/server/src/controllers/index.ts

@@ -3,3 +3,4 @@ export * from "./ChatController";
 export * from "./EventController";
 export * from "./AuthMiddleware";
 export * from "./LoggingMiddleware";
+export * from "./CaldavController";

apps/server/src/repositories/mongo/MongoCaldavRepository.ts

@@ -0,0 +1,31 @@
+import { CaldavConfig } from "@calchat/shared";
+import { Logged } from "../../logging/Logged";
+import { CaldavRepository } from "../../services/interfaces/CaldavRepository";
+import { CaldavConfigModel } from "./models/CaldavConfigModel";
+
+@Logged("MongoCaldavRepository")
+export class MongoCaldavRepository implements CaldavRepository {
+  async findByUserId(userId: string): Promise<CaldavConfig | null> {
+    const config = await CaldavConfigModel.findOne({ userId });
+    if (!config) return null;
+    return config.toJSON() as unknown as CaldavConfig;
+  }
+
+  async createOrUpdate(config: CaldavConfig): Promise<CaldavConfig> {
+    const caldavConfig = await CaldavConfigModel.findOneAndUpdate(
+      { userId: config.userId },
+      config,
+      {
+        upsert: true,
+        new: true,
+      },
+    );
+    // NOTE: Casting required because Mongoose's toJSON() type doesn't reflect our virtual 'id' field
+    return caldavConfig.toJSON() as unknown as CaldavConfig;
+  }
+
+  async deleteByUserId(userId: string): Promise<boolean> {
+    const result = await CaldavConfigModel.findOneAndDelete({userId});
+    return result !== null;
+  }
+}

apps/server/src/repositories/mongo/MongoEventRepository.ts

@@ -28,6 +28,12 @@ export class MongoEventRepository implements EventRepository {
     return events.map((e) => e.toJSON() as unknown as CalendarEvent);
   }
 
+  async findByCaldavUUID(userId: string, caldavUUID: string): Promise<CalendarEvent | null> {
+    const event = await EventModel.findOne({ userId, caldavUUID });
+    if (!event) return null;
+    return event.toJSON() as unknown as CalendarEvent;
+  }
+
   async searchByTitle(userId: string, query: string): Promise<CalendarEvent[]> {
     const events = await EventModel.find({
       userId,

apps/server/src/repositories/mongo/models/CaldavConfigModel.ts

@@ -0,0 +1,22 @@
+import { CaldavConfig } from "@calchat/shared";
+import mongoose, { Document, Schema } from "mongoose";
+
+export interface CaldavConfigDocument extends CaldavConfig, Document {
+  toJSON(): CaldavConfig;
+}
+
+const CaldavConfigSchema = new Schema<CaldavConfigDocument>(
+  {
+    userId: { type: String, required: true, index: true },
+    serverUrl: { type: String, required: true },
+    username: { type: String, required: true },
+    password: { type: String, required: true },
+    syncIntervalSeconds: { type: Number },
+  },
+  { _id: false },
+);
+
+export const CaldavConfigModel = mongoose.model<CaldavConfigDocument>(
+  "CaldavConfig",
+  CaldavConfigSchema,
+);

apps/server/src/repositories/mongo/models/EventModel.ts

@@ -21,6 +21,12 @@ const EventSchema = new Schema<
       required: true,
       index: true,
     },
+    caldavUUID: {
+      type: String,
+    },
+    etag: {
+      type: String,
+    },
     title: {
       type: String,
       required: true,

apps/server/src/routes/caldav.routes.ts

@@ -0,0 +1,22 @@
+import { Router } from "express";
+import { authenticate } from "../controllers";
+import { CaldavController } from "../controllers/CaldavController";
+
+export function createCaldavRoutes(caldavController: CaldavController): Router {
+  const router = Router();
+
+  router.use(authenticate);
+
+  router.put("/config", (req, res) => caldavController.saveConfig(req, res));
+  router.get("/config", (req, res) => caldavController.loadConfig(req, res));
+  router.delete("/config", (req, res) =>
+    caldavController.deleteConfig(req, res),
+  );
+  router.post("/pull", (req, res) => caldavController.pullEvents(req, res));
+  router.post("/pushAll", (req, res) => caldavController.pushEvents(req, res));
+  router.post("/push/:caldavUUID", (req, res) =>
+    caldavController.pushEvent(req, res),
+  );
+
+  return router;
+}

apps/server/src/routes/index.ts

@@ -6,12 +6,15 @@ import {
   AuthController,
   ChatController,
   EventController,
+  CaldavController
 } from "../controllers";
+import { createCaldavRoutes } from "./caldav.routes";
 
 export interface Controllers {
   authController: AuthController;
   chatController: ChatController;
   eventController: EventController;
+  caldavController: CaldavController;
 }
 
 export function createRoutes(controllers: Controllers): Router {
@@ -20,6 +23,7 @@ export function createRoutes(controllers: Controllers): Router {
   router.use("/auth", createAuthRoutes(controllers.authController));
   router.use("/chat", createChatRoutes(controllers.chatController));
   router.use("/events", createEventRoutes(controllers.eventController));
+  router.use("/caldav", createCaldavRoutes(controllers.caldavController));
 
   return router;
 }

apps/server/src/services/CaldavService.test.ts

@@ -0,0 +1,11 @@
+// import { createLogger } from "../logging";
+// import { CaldavService } from "./CaldavService";
+//
+// const logger = createLogger("CaldavService-Test");
+//
+// const cdService = new CaldavService();
+//
+// test("print events", async () => {
+//   const client = await cdService.login();
+//   await cdService.pullEvents(client);
+// });

apps/server/src/services/CaldavService.ts

@@ -0,0 +1,260 @@
+import crypto from "crypto";
+import { DAVClient } from "tsdav";
+import ICAL from "ical.js";
+import { createLogger } from "../logging/logger";
+import { CaldavRepository } from "./interfaces/CaldavRepository";
+import {
+  CalendarEvent,
+  CreateEventDTO,
+} from "@calchat/shared/src/models/CalendarEvent";
+import { EventService } from "./EventService";
+import { CaldavConfig, formatDateKey } from "@calchat/shared";
+
+const logger = createLogger("CaldavService");
+
+export class CaldavService {
+  constructor(
+    private caldavRepo: CaldavRepository,
+    private eventService: EventService,
+  ) {}
+
+  /**
+   * Login to CalDAV server and return client + first calendar.
+   */
+  async connect(userId: string) {
+    const config = await this.caldavRepo.findByUserId(userId);
+    if (config === null) {
+      throw new Error(`Coudn't find config by user id ${userId}`);
+    }
+    const client = new DAVClient({
+      serverUrl: config.serverUrl,
+      credentials: {
+        username: config.username,
+        password: config.password,
+      },
+      authMethod: "Basic",
+      defaultAccountType: "caldav",
+    });
+
+    try {
+      await client.login();
+    } catch (error) {
+      throw new Error("Caldav login failed");
+    }
+
+    const calendars = await client.fetchCalendars();
+    if (calendars.length === 0) {
+      throw new Error("No calendars found on CalDAV server");
+    }
+
+    return { client, calendar: calendars[0] };
+  }
+
+  /**
+   * Pull events from CalDAV server and sync with local database.
+   * - Compares etags to skip unchanged events
+   * - Creates new or updates existing events in the database
+   * - Deletes local events that were removed on the CalDAV server
+   *
+   * @returns List of newly created or updated events
+   */
+  async pullEvents(userId: string): Promise<CalendarEvent[]> {
+    const { client, calendar } = await this.connect(userId);
+    const calendarEvents: CalendarEvent[] = [];
+    const caldavEventUUIDs = new Set<string>();
+
+    const events = await client.fetchCalendarObjects({ calendar });
+    for (const event of events) {
+      const etag = event.etag;
+      const jcal = ICAL.parse(event.data);
+      const comp = new ICAL.Component(jcal);
+      // A CalendarObject (.ics file) can contain multiple VEVENTs (e.g.
+      // recurring events with RECURRENCE-ID exceptions), but the etag belongs
+      // to the whole file, not individual VEVENTs. We only need the first
+      // VEVENT since we handle recurrence via RRULE/exceptionDates, not as
+      // separate events.
+      const vevent = comp.getFirstSubcomponent("vevent");
+      if (!vevent) continue;
+
+      const icalEvent = new ICAL.Event(vevent);
+      caldavEventUUIDs.add(icalEvent.uid);
+
+      const exceptionDates = vevent
+        .getAllProperties("exdate")
+        .flatMap((prop) => prop.getValues())
+        .map((time: ICAL.Time) => formatDateKey(time.toJSDate()));
+
+      const existingEvent = await this.eventService.findByCaldavUUID(
+        userId,
+        icalEvent.uid,
+      );
+
+      const didChange = existingEvent?.etag !== etag;
+
+      if (existingEvent && !didChange) {
+        continue;
+      }
+
+      const eventObject: CreateEventDTO = {
+        caldavUUID: icalEvent.uid,
+        etag,
+        title: icalEvent.summary,
+        description: icalEvent.description,
+        startTime: icalEvent.startDate.toJSDate(),
+        endTime: icalEvent.endDate.toJSDate(),
+        recurrenceRule: vevent.getFirstPropertyValue("rrule")?.toString(),
+        exceptionDates,
+        caldavSyncStatus: "synced",
+      };
+
+      const calendarEvent = existingEvent
+        ? await this.eventService.update(existingEvent.id, userId, eventObject)
+        : await this.eventService.create(userId, eventObject);
+
+      if (calendarEvent) {
+        calendarEvents.push(calendarEvent);
+      }
+    }
+
+    // delete all events, that got deleted remotely
+    const localEvents = await this.eventService.getAll(userId);
+    for (const localEvent of localEvents) {
+      if (
+        localEvent.caldavUUID &&
+        !caldavEventUUIDs.has(localEvent.caldavUUID)
+      ) {
+        await this.eventService.delete(localEvent.id, userId);
+      }
+    }
+
+    return calendarEvents;
+  }
+
+  /**
+   * Push a single event to the CalDAV server.
+   * Creates a new event if no caldavUUID exists, updates otherwise.
+   */
+  async pushEvent(userId: string, event: CalendarEvent): Promise<void> {
+    const { client, calendar } = await this.connect(userId);
+
+    try {
+      if (event.caldavUUID) {
+        await client.updateCalendarObject({
+          calendarObject: {
+            url: `${calendar.url}${event.caldavUUID}.ics`,
+            data: this.toICalString(event.caldavUUID, event),
+            etag: event.etag || "",
+          },
+        });
+      } else {
+        const uid = crypto.randomUUID();
+        await client.createCalendarObject({
+          calendar,
+          filename: `${uid}.ics`,
+          iCalString: this.toICalString(uid, event),
+        });
+        await this.eventService.update(event.id, userId, { caldavUUID: uid });
+      }
+
+      // Fetch updated etag from server
+      const objects = await client.fetchCalendarObjects({ calendar });
+      const caldavUUID =
+        event.caldavUUID ||
+        (await this.eventService.getById(event.id, userId))?.caldavUUID;
+      const pushed = objects.find((o) => o.data?.includes(caldavUUID!));
+
+      await this.eventService.update(event.id, userId, {
+        etag: pushed?.etag || undefined,
+        caldavSyncStatus: "synced",
+      });
+    } catch (error) {
+      await this.eventService.update(event.id, userId, {
+        caldavSyncStatus: "error",
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Build an iCalendar string from a CalendarEvent using ical.js.
+   */
+  private toICalString(uid: string, event: CalendarEvent): string {
+    const vcalendar = new ICAL.Component("vcalendar");
+    vcalendar.addPropertyWithValue("version", "2.0");
+    vcalendar.addPropertyWithValue("prodid", "-//CalChat//EN");
+
+    const vevent = new ICAL.Component("vevent");
+    vevent.addPropertyWithValue("uid", uid);
+    vevent.addPropertyWithValue("summary", event.title);
+    vevent.addPropertyWithValue(
+      "dtstart",
+      ICAL.Time.fromJSDate(new Date(event.startTime)),
+    );
+    vevent.addPropertyWithValue(
+      "dtend",
+      ICAL.Time.fromJSDate(new Date(event.endTime)),
+    );
+
+    if (event.description) {
+      vevent.addPropertyWithValue("description", event.description);
+    }
+
+    if (event.recurrenceRule) {
+      // Strip RRULE: prefix if present — fromString expects only the value part,
+      // and addPropertyWithValue("rrule", ...) adds the RRULE: prefix automatically.
+      const rule = event.recurrenceRule.replace(/^RRULE:/i, "");
+      vevent.addPropertyWithValue("rrule", ICAL.Recur.fromString(rule));
+    }
+
+    if (event.exceptionDates?.length) {
+      for (const exdate of event.exceptionDates) {
+        vevent.addPropertyWithValue("exdate", ICAL.Time.fromDateString(exdate));
+      }
+    }
+
+    vcalendar.addSubcomponent(vevent);
+    return vcalendar.toString();
+  }
+
+  async pushAll(userId: string): Promise<void> {
+    const allEvents = await this.eventService.getAll(userId);
+    for (const event of allEvents) {
+      if (event.caldavSyncStatus !== "synced") {
+        await this.pushEvent(userId, event);
+      }
+    }
+  }
+
+  async deleteEvent(userId: string, caldavUUID: string) {
+    const { client, calendar } = await this.connect(userId);
+
+    await client.deleteCalendarObject({
+      calendarObject: {
+        url: `${calendar.url}${caldavUUID}.ics`,
+      },
+    });
+  }
+
+  async findEventByCaldavUUID(userId: string, caldavUUID: string) {
+    return this.eventService.findByCaldavUUID(userId, caldavUUID);
+  }
+
+  async getConfig(userId: string): Promise<CaldavConfig | null> {
+    return this.caldavRepo.findByUserId(userId);
+  }
+
+  async saveConfig(config: CaldavConfig): Promise<CaldavConfig> {
+    const savedConfig = await this.caldavRepo.createOrUpdate(config);
+    try {
+      await this.connect(savedConfig.userId);
+    } catch (error) {
+      await this.caldavRepo.deleteByUserId(savedConfig.userId);
+      throw new Error("failed to connect");
+    }
+    return savedConfig;
+  }
+
+  async deleteConfig(userId: string) {
+    return await this.caldavRepo.deleteByUserId(userId);
+  }
+}

apps/server/src/services/ChatService.ts

@@ -12,7 +12,7 @@ import {
   RecurringDeleteMode,
   ConflictingEvent,
 } from "@calchat/shared";
-import { ChatRepository, EventRepository, AIProvider } from "./interfaces";
+import { ChatRepository, AIProvider } from "./interfaces";
 import { EventService } from "./EventService";
 import { getWeeksOverview, getMonthOverview } from "../utils/eventFormatters";
 
@@ -333,7 +333,7 @@ const staticResponses: TestResponse[] = [
 
 async function getTestResponse(
   index: number,
-  eventRepo: EventRepository,
+  eventService: EventService,
   userId: string,
 ): Promise<TestResponse> {
   const responseIdx = index % staticResponses.length;
@@ -341,7 +341,7 @@ async function getTestResponse(
   // === SPORT TEST SCENARIO (Dynamic responses) ===
   // Response 1: Add exception to "Sport" (2 weeks later)
   if (responseIdx === 1) {
-    const events = await eventRepo.findByUserId(userId);
+    const events = await eventService.getAll(userId);
     const sportEvent = events.find((e) => e.title === "Sport");
     if (sportEvent) {
       // Calculate date 2 weeks from the first occurrence
@@ -380,7 +380,7 @@ async function getTestResponse(
 
   // Response 2: Add UNTIL to "Sport" (after 6 weeks total)
   if (responseIdx === 2) {
-    const events = await eventRepo.findByUserId(userId);
+    const events = await eventService.getAll(userId);
     const sportEvent = events.find((e) => e.title === "Sport");
     if (sportEvent) {
       // Calculate UNTIL date: 6 weeks from start
@@ -418,7 +418,7 @@ async function getTestResponse(
 
   // Response 3: Add another exception to "Sport" (2 weeks after the first exception)
   if (responseIdx === 3) {
-    const events = await eventRepo.findByUserId(userId);
+    const events = await eventService.getAll(userId);
     const sportEvent = events.find((e) => e.title === "Sport");
     if (sportEvent) {
       // Calculate date 4 weeks from the first occurrence (2 weeks after the first exception)
@@ -458,12 +458,12 @@ async function getTestResponse(
   // Dynamic responses: fetch events from DB and format
   // (Note: indices shifted by +3 due to new sport responses)
   if (responseIdx === 6) {
-    return { content: await getWeeksOverview(eventRepo, userId, 2) };
+    return { content: await getWeeksOverview(eventService, userId, 2) };
   }
 
   if (responseIdx === 7) {
     // Delete "Meeting mit Jens"
-    const events = await eventRepo.findByUserId(userId);
+    const events = await eventService.getAll(userId);
     const jensEvent = events.find((e) => e.title === "Meeting mit Jens");
     if (jensEvent) {
       return {
@@ -487,12 +487,12 @@ async function getTestResponse(
   }
 
   if (responseIdx === 11) {
-    return { content: await getWeeksOverview(eventRepo, userId, 1) };
+    return { content: await getWeeksOverview(eventService, userId, 1) };
   }
 
   if (responseIdx === 13) {
     // Update "Telefonat mit Mama" +3 days and change time to 13:00
-    const events = await eventRepo.findByUserId(userId);
+    const events = await eventService.getAll(userId);
     const mamaEvent = events.find((e) => e.title === "Telefonat mit Mama");
     if (mamaEvent) {
       const newStart = new Date(mamaEvent.startTime);
@@ -527,7 +527,7 @@ async function getTestResponse(
     const now = new Date();
     return {
       content: await getMonthOverview(
-        eventRepo,
+        eventService,
         userId,
         now.getFullYear(),
         now.getMonth(),
@@ -541,7 +541,6 @@ async function getTestResponse(
 export class ChatService {
   constructor(
     private chatRepo: ChatRepository,
-    private eventRepo: EventRepository,
     private eventService: EventService,
     private aiProvider: AIProvider,
   ) {}
@@ -566,7 +565,7 @@ export class ChatService {
 
     if (process.env.USE_TEST_RESPONSES === "true") {
       // Test mode: use static responses
-      response = await getTestResponse(responseIndex, this.eventRepo, userId);
+      response = await getTestResponse(responseIndex, this.eventService, userId);
       responseIndex++;
     } else {
       // Production mode: use real AI
@@ -582,7 +581,7 @@ export class ChatService {
           return this.eventService.getByDateRange(userId, start, end);
         },
         searchEvents: async (query) => {
-          return this.eventRepo.searchByTitle(userId, query);
+          return this.eventService.searchByTitle(userId, query);
         },
         fetchEventById: async (eventId) => {
           return this.eventService.getById(eventId, userId);
@@ -623,10 +622,10 @@ export class ChatService {
     let content: string;
 
     if (action === "create" && event) {
-      const createdEvent = await this.eventRepo.create(userId, event);
+      const createdEvent = await this.eventService.create(userId, event);
       content = `Der Termin "${createdEvent.title}" wurde erstellt.`;
     } else if (action === "update" && eventId && updates) {
-      const updatedEvent = await this.eventRepo.update(eventId, updates);
+      const updatedEvent = await this.eventService.update(eventId, userId, updates);
       content = updatedEvent
         ? `Der Termin "${updatedEvent.title}" wurde aktualisiert.`
         : "Termin nicht gefunden.";

apps/server/src/services/EventService.ts

@@ -24,10 +24,18 @@ export class EventService {
     return event;
   }
 
+  async findByCaldavUUID(userId: string, caldavUUID: string): Promise<CalendarEvent | null> {
+    return this.eventRepo.findByCaldavUUID(userId, caldavUUID);
+  }
+
   async getAll(userId: string): Promise<CalendarEvent[]> {
     return this.eventRepo.findByUserId(userId);
   }
 
+  async searchByTitle(userId: string, query: string): Promise<CalendarEvent[]> {
+    return this.eventRepo.searchByTitle(userId, query);
+  }
+
   async getByDateRange(
     userId: string,
     startDate: Date,

apps/server/src/services/interfaces/CaldavRepository.ts

@@ -0,0 +1,7 @@
+import { CaldavConfig } from "@calchat/shared/src/models/CaldavConfig";
+
+export interface CaldavRepository {
+  findByUserId(userId: string): Promise<CaldavConfig | null>;
+  createOrUpdate(config: CaldavConfig): Promise<CaldavConfig>;
+  deleteByUserId(userId: string): Promise<boolean>;
+}

apps/server/src/services/interfaces/EventRepository.ts

@@ -8,6 +8,7 @@ export interface EventRepository {
     startDate: Date,
     endDate: Date,
   ): Promise<CalendarEvent[]>;
+  findByCaldavUUID(userId: string, caldavUUID: string): Promise<CalendarEvent | null>;
   searchByTitle(userId: string, query: string): Promise<CalendarEvent[]>;
   create(userId: string, data: CreateEventDTO): Promise<CalendarEvent>;
   update(id: string, data: UpdateEventDTO): Promise<CalendarEvent | null>;

apps/server/src/utils/eventFormatters.ts

@@ -6,7 +6,7 @@ import {
   MONTH_TO_GERMAN,
   ExpandedEvent,
 } from "@calchat/shared";
-import { EventRepository } from "../services/interfaces";
+import { EventService } from "../services/EventService";
 import { expandRecurringEvents } from "./recurrenceExpander";
 
 // Private formatting helpers
@@ -107,13 +107,13 @@ function formatMonthText(events: ExpandedEvent[], monthName: string): string {
  * Recurring events are expanded to show all occurrences within the range.
  */
 export async function getWeeksOverview(
-  eventRepo: EventRepository,
+  eventService: EventService,
   userId: string,
   weeks: number,
 ): Promise<string> {
   const now = new Date();
   const endDate = new Date(now.getTime() + weeks * 7 * 24 * 60 * 60 * 1000);
-  const events = await eventRepo.findByUserId(userId);
+  const events = await eventService.getAll(userId);
   const expanded = expandRecurringEvents(events, now, endDate);
   return formatWeeksText(expanded, weeks);
 }
@@ -123,14 +123,14 @@ export async function getWeeksOverview(
  * Recurring events are expanded to show all occurrences within the month.
  */
 export async function getMonthOverview(
-  eventRepo: EventRepository,
+  eventService: EventService,
   userId: string,
   year: number,
   month: number,
 ): Promise<string> {
   const startOfMonth = new Date(year, month, 1);
   const endOfMonth = new Date(year, month + 1, 0, 23, 59, 59);
-  const events = await eventRepo.findByUserId(userId);
+  const events = await eventService.getAll(userId);
   const expanded = expandRecurringEvents(events, startOfMonth, endOfMonth);
   const monthName = MONTH_TO_GERMAN[MONTHS[month]];
   return formatMonthText(expanded, monthName);

apps/server/src/utils/recurrenceExpander.ts

@@ -1,5 +1,5 @@
 import { RRule, rrulestr } from "rrule";
-import { CalendarEvent, ExpandedEvent } from "@calchat/shared";
+import { CalendarEvent, ExpandedEvent, formatDateKey } from "@calchat/shared";
 
 // Convert local time to "fake UTC" for rrule
 // rrule interprets all dates as UTC internally, so we need to trick it
@@ -133,11 +133,3 @@ function formatRRuleDateString(date: Date): string {
   const seconds = String(date.getSeconds()).padStart(2, "0");
   return `${year}${month}${day}T${hours}${minutes}${seconds}`;
 }
-
-// Format date as YYYY-MM-DD for exception date comparison
-function formatDateKey(date: Date): string {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}