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
2026-02-08 19:24:59 +01:00
parent 81221d8b70
commit 325246826a
44 changed files with 7074 additions and 126 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,5 @@ node_modules
 docs/praesi_2_context.md
 docs/*.png
 .env
+apps/server/docker/radicale/config/
+apps/server/docker/radicale/data/
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -51,6 +51,8 @@ npm run start -w @calchat/server        # Run compiled server (port 3000)
 | | X-User-Id Header | Authentication (simple, no JWT yet) |
 | | pino / pino-http | Structured logging |
 | | react-native-logs | Client-side logging |
+| | tsdav | CalDAV client library |
+| | ical.js | iCalendar parsing/generation |
 | Planned | iCalendar | Event export/import |

 ## Architecture
@@ -82,7 +84,7 @@ src/
 │   └── note/
 │       └── [id].tsx            # Note editor for event (dynamic route)
 ├── components/
-│   ├── AuthGuard.tsx           # Auth wrapper: loads user, shows loading, redirects if unauthenticated
+│   ├── AuthGuard.tsx           # Auth wrapper: loads user, CalDAV sync on auto-login, shows loading, redirects if unauthenticated
 │   ├── BaseBackground.tsx      # Common screen wrapper (themed)
 │   ├── BaseButton.tsx          # Reusable button component (themed, supports children)
 │   ├── Header.tsx              # Header component (themed)
@@ -96,6 +98,7 @@ src/
 │   ├── EventConfirmDialog.tsx  # AI-proposed event confirmation modal (skeleton)
 │   ├── ProposedEventCard.tsx   # Chat event proposal (uses EventCardBase + confirm/reject/edit buttons)
 │   ├── DeleteEventModal.tsx    # Delete confirmation modal (uses ModalBase)
+│   ├── CustomTextInput.tsx     # Themed text input with focus border (used in CaldavSettings)
 │   ├── DateTimePicker.tsx      # Date and time picker components
 │   └── ScrollableDropdown.tsx  # Scrollable dropdown component
 ├── Themes.tsx                  # Theme definitions: THEMES object with defaultLight/defaultDark, Theme type
@@ -107,7 +110,8 @@ src/
 │   ├── ApiClient.ts            # HTTP client with X-User-Id header injection, request logging, handles empty responses (204)
 │   ├── AuthService.ts          # login(), register(), logout() - calls API and updates AuthStore
 │   ├── EventService.ts         # getAll(), getById(), getByDateRange(), create(), update(), delete(mode, occurrenceDate)
-│   └── ChatService.ts          # sendMessage(), confirmEvent(deleteMode, occurrenceDate), rejectEvent(), getConversations(), getConversation(), updateProposalEvent()
+│   ├── ChatService.ts          # sendMessage(), confirmEvent(deleteMode, occurrenceDate), rejectEvent(), getConversations(), getConversation(), updateProposalEvent()
+│   └── CaldavConfigService.ts  # saveConfig(), getConfig(), deleteConfig(), pull(), pushAll(), sync()
 ├── stores/                     # Zustand state management
 │   ├── index.ts                # Re-exports all stores
 │   ├── AuthStore.ts            # user, isAuthenticated, isLoading, login(), logout(), loadStoredUser()
@@ -228,8 +232,9 @@ src/
 ├── app.ts                    # Entry point, DI setup, Express config
 ├── controllers/              # Request handlers + middleware (per architecture diagram)
 │   ├── AuthController.ts     # login(), register(), refresh(), logout()
-│   ├── ChatController.ts     # sendMessage(), confirmEvent(), rejectEvent(), getConversations(), getConversation(), updateProposalEvent()
-│   ├── EventController.ts    # create(), getById(), getAll(), getByDateRange(), update(), delete()
+│   ├── ChatController.ts     # sendMessage(), confirmEvent() + CalDAV push, rejectEvent(), getConversations(), getConversation(), updateProposalEvent()
+│   ├── EventController.ts    # create(), getById(), getAll(), getByDateRange(), update(), delete() - pushes/deletes to CalDAV on mutations
+│   ├── CaldavController.ts   # saveConfig(), loadConfig(), deleteConfig(), pullEvents(), pushEvents(), pushEvent()
 │   ├── AuthMiddleware.ts     # authenticate() - X-User-Id header validation
 │   └── LoggingMiddleware.ts  # httpLogger - pino-http request logging
 ├── logging/
@@ -240,16 +245,19 @@ src/
 │   ├── index.ts              # Combines all routes under /api
 │   ├── auth.routes.ts        # /api/auth/*
 │   ├── chat.routes.ts        # /api/chat/* (protected)
-│   └── event.routes.ts       # /api/events/* (protected)
+│   ├── event.routes.ts       # /api/events/* (protected)
+│   └── caldav.routes.ts      # /api/caldav/* (protected)
 ├── services/                 # Business logic
 │   ├── interfaces/           # DB-agnostic interfaces (for dependency injection)
 │   │   ├── AIProvider.ts     # processMessage()
 │   │   ├── UserRepository.ts # findById, findByEmail, findByUserName, create + CreateUserData
 │   │   ├── EventRepository.ts
-│   │   └── ChatRepository.ts
+│   │   ├── ChatRepository.ts
+│   │   └── CaldavRepository.ts
 │   ├── AuthService.ts
 │   ├── ChatService.ts
-│   └── EventService.ts
+│   ├── EventService.ts
+│   └── CaldavService.ts      # connect(), pullEvents(), pushEvent(), pushAll(), deleteEvent(), sync logic
 ├── repositories/             # Data access (DB-specific implementations)
 │   ├── index.ts              # Re-exports from ./mongo
 │   └── mongo/                # MongoDB implementation
@@ -257,10 +265,12 @@ src/
 │       │   ├── types.ts      # Shared types (IdVirtual interface)
 │       │   ├── UserModel.ts
 │       │   ├── EventModel.ts
-│       │   └── ChatModel.ts
+│       │   ├── ChatModel.ts
+│       │   └── CaldavConfigModel.ts
 │       ├── MongoUserRepository.ts  # findById, findByEmail, findByUserName, create
 │       ├── MongoEventRepository.ts
-│       └── MongoChatRepository.ts
+│       ├── MongoChatRepository.ts
+│       └── MongoCaldavRepository.ts
 ├── ai/
 │   ├── GPTAdapter.ts         # Implements AIProvider using OpenAI GPT
 │   ├── index.ts              # Re-exports GPTAdapter
@@ -296,6 +306,12 @@ src/
 - `GET /api/chat/conversations` - Get all conversations (protected)
 - `GET /api/chat/conversations/:id` - Get messages of a conversation with cursor-based pagination (protected)
 - `PUT /api/chat/messages/:messageId/proposal` - Update proposal event data before confirming (protected)
+- `PUT /api/caldav/config` - Save CalDAV config (protected)
+- `GET /api/caldav/config` - Load CalDAV config (protected)
+- `DELETE /api/caldav/config` - Delete CalDAV config (protected)
+- `POST /api/caldav/pull` - Pull events from CalDAV server (protected)
+- `POST /api/caldav/pushAll` - Push all unsynced events (protected)
+- `POST /api/caldav/push/:caldavUUID` - Push single event (protected)
 - `GET /health` - Health check
 - `POST /api/ai/test` - AI test endpoint (development only)

@@ -307,7 +323,8 @@ src/
 ├── models/
 │   ├── index.ts
 │   ├── User.ts           # User, CreateUserDTO, LoginDTO, AuthResponse
-│   ├── CalendarEvent.ts  # CalendarEvent, CreateEventDTO, UpdateEventDTO, ExpandedEvent
+│   ├── CalendarEvent.ts  # CalendarEvent, CreateEventDTO, UpdateEventDTO, ExpandedEvent, CaldavSyncStatus
+│   ├── CaldavConfig.ts   # CaldavConfig
 │   ├── ChatMessage.ts    # ChatMessage, Conversation, SendMessageDTO, CreateMessageDTO,
 │   │                     # GetMessagesOptions, ChatResponse, ConversationSummary,
 │   │                     # ProposedEventChange, EventAction, RespondedAction, UpdateMessageDTO
@@ -322,7 +339,9 @@ src/

 **Key Types:**
 - `User`: id, email, userName, passwordHash?, createdAt?, updatedAt?
- `CalendarEvent`: id, userId, title, description?, startTime, endTime, note?, isRecurring?, recurrenceRule?, exceptionDates?
+- `CalendarEvent`: id, userId, caldavUUID?, etag?, title, description?, startTime, endTime, note?, recurrenceRule?, exceptionDates?, caldavSyncStatus?
+- `CaldavConfig`: userId, serverUrl, username, password, syncIntervalSeconds?
+- `CaldavSyncStatus`: 'synced' | 'error'
 - `ExpandedEvent`: Extends CalendarEvent with occurrenceStart, occurrenceEnd (for recurring event instances)
 - `ChatMessage`: id, conversationId, sender ('user' | 'assistant'), content, proposedChanges?
 - `ProposedEventChange`: id, action ('create' | 'update' | 'delete'), eventId?, event?, updates?, respondedAction?, deleteMode?, occurrenceDate?, conflictingEvents?
@@ -377,6 +396,32 @@ When creating events, `toolExecutor` automatically:
 3. Returns `conflictingEvents` array in the proposal for UI display
 4. Adds ⚠️ warning to tool result so AI can inform user

+### CalDAV Synchronization
+
+CalDAV sync with external calendar servers (e.g., Radicale) using `tsdav` and `ical.js`.
+
+**Naming Convention:** All CalDAV-related identifiers use `Caldav` (PascalCase) / `caldav` (camelCase), NOT `CalDav`. The only exception is the protocol name "CalDAV" in comments and log messages.
+
+**Sync Triggers (client-side via `CaldavConfigService.sync()`):**
+- **Login** (`login.tsx`): After successful authentication
+- **Auto-login** (`AuthGuard.tsx`): After `loadStoredUser()` if authenticated
+- **Calendar timer** (`calendar.tsx`): Every 10s while Calendar tab is focused, via `setInterval` in `useFocusEffect`
+- **Sync button** (`settings.tsx`): Manual trigger in CaldavSettings
+
+**Single-event sync (server-side in controllers):**
+- `EventController`: `pushToCaldav()` after create/update, `deleteFromCaldav()` after delete
+- `ChatController`: `pushAll()` after confirming an event proposal
+
+**Sync Flow:**
+1. `sync()` calls `pushAll` (push unsynced local events) then `pull` (fetch remote events)
+2. `pullEvents`: Compares etags to skip unchanged events, creates/updates local events, deletes locally if removed remotely
+3. `pushEvent`: Creates or updates remote event, fetches new etag after push
+
+**Architecture:**
+- `CaldavService` depends on `CaldavRepository` (config storage) and `EventService` (event CRUD)
+- `ChatService` depends only on `EventService` (not EventRepository) for all event operations
+- `EventController` and `ChatController` both receive `CaldavService` for CalDAV push on mutations
+
 ### Database Abstraction

 The repository pattern allows swapping databases:
@@ -460,7 +505,7 @@ The `@Logged` decorator automatically summarizes large arguments to keep logs re
 ### Nice-to-Have
 - iCalendar import/export
 - Multiple calendars
- CalDAV synchronization with external services
+- ~~CalDAV synchronization with external services~~ (implemented)

 ## Development Environment

@@ -473,6 +518,13 @@ docker compose down                   # Stop services
 - MongoDB: `localhost:27017` (root/mongoose)
 - Mongo Express UI: `localhost:8083` (admin/admin)

+### Radicale CalDAV Server (Docker)
+```bash
+cd apps/server/docker/radicale
+docker compose up -d                  # Start Radicale CalDAV server
+```
+- Radicale: `localhost:5232`
+
 ### Environment Variables
 Server requires `.env` file in `apps/server/`:
 ```
@@ -510,12 +562,20 @@ NODE_ENV=development        # development = pretty logs, production = JSON
  - `GPTAdapter`: Full implementation with OpenAI GPT (gpt-4o-mini model), function calling for calendar operations, collects multiple proposals per response
  - `ai/utils/`: Provider-agnostic shared utilities (systemPrompt, toolDefinitions, toolExecutor)
  - `ai/utils/systemPrompt`: AI fetches events on-demand (no pre-loaded context), includes RRULE documentation, warns AI not to put RRULE in description field, instructs AI not to show event IDs to users
-  - `ai/utils/toolDefinitions`: proposeUpdateEvent supports `isRecurring` and `recurrenceRule` parameters, getEventsInRange tool for on-demand event loading
+  - `ai/utils/toolDefinitions`: proposeUpdateEvent supports `recurrenceRule` parameter, getEventsInRange tool for on-demand event loading
  - `ai/utils/toolExecutor`: Async execution, conflict detection uses `occurrenceStart/occurrenceEnd` for recurring events, returns `conflictingEvents` in proposals
  - `MongoEventRepository`: Includes `searchByTitle()` for case-insensitive title search
  - `utils/recurrenceExpander`: Handles RRULE parsing, strips `RRULE:` prefix if present (AI may include it), filters out exceptionDates
  - `logging/`: Structured logging with pino, pino-http middleware, @Logged decorator
  - All repositories and GPTAdapter decorated with @Logged for automatic method logging
+  - `CaldavService`: Full CalDAV sync (connect, pullEvents, pushEvent, pushAll, deleteEvent, getConfig, saveConfig, deleteConfig)
+  - `CaldavController`: REST endpoints for config CRUD, pull, push
+  - `MongoCaldavRepository`: Config persistence with createOrUpdate, findByUserId, deleteByUserId
+  - `EventController`: CalDAV push on create/update, CalDAV delete on delete (via pushToCaldav/deleteFromCaldav helpers)
+  - `ChatController`: CalDAV pushAll after confirmEvent (ensures chat-created events sync)
+  - `ChatService`: Refactored to use only EventService (no direct EventRepository dependency)
+  - `EventService`: Extended with searchByTitle(), findByCaldavUUID()
+  - `utils/eventFormatters`: Refactored to use EventService instead of EventRepository
  - CORS configured to allow X-User-Id header
 - **Stubbed (TODO):**
  - `AuthController`: refresh(), logout()
@@ -523,9 +583,9 @@ NODE_ENV=development        # development = pretty logs, production = JSON
  - JWT authentication (currently using simple X-User-Id header)

 **Shared:**
- Types, DTOs, constants (Day, Month with German translations), ExpandedEvent type defined and exported
+- Types, DTOs, constants (Day, Month with German translations), ExpandedEvent type, CaldavConfig, CaldavSyncStatus defined and exported
 - `rruleHelpers.ts`: `parseRRule()` parses RRULE strings using rrule library, returns `ParsedRRule` with freq, until, count, interval, byDay
- `formatters.ts`: German date/time formatters (`formatDate`, `formatTime`, `formatDateTime`, `formatDateWithWeekday`) used by both client and server
+- `formatters.ts`: German date/time formatters (`formatDate`, `formatTime`, `formatDateTime`, `formatDateWithWeekday`, `formatDateKey`) used by both client and server
 - rrule library added as dependency for RRULE parsing

 **Frontend:**
@@ -533,8 +593,8 @@ NODE_ENV=development        # development = pretty logs, production = JSON
  - `AuthStore`: Manages user state with expo-secure-store (native) / localStorage (web)
  - `AuthService`: login(), register(), logout() - calls backend API
  - `ApiClient`: Automatically injects X-User-Id header for authenticated requests, handles empty responses (204)
-  - `AuthGuard`: Reusable component that wraps protected routes - loads user, shows loading, redirects if unauthenticated
-  - Login screen: Supports email OR userName login
+  - `AuthGuard`: Reusable component that wraps protected routes - loads user, triggers CalDAV sync on auto-login, shows loading, redirects if unauthenticated
+  - Login screen: Supports email OR userName login, triggers CalDAV sync after successful login
  - Register screen: Email validation, checks for existing email/userName
  - `AuthButton`: Reusable button component with themed shadow
  - `Header`: Themed header component (logout moved to Settings)
@@ -544,7 +604,7 @@ NODE_ENV=development        # development = pretty logs, production = JSON
  - `ThemeStore`: Zustand store with theme state and setTheme()
  - `Themes.tsx`: THEMES object with defaultLight/defaultDark variants
  - All components use `useThemeStore()` for reactive theme colors
-  - Settings screen with theme switcher (light/dark)
+  - Settings screen with theme switcher (light/dark) and CalDAV configuration (url, username, password with save/sync buttons, loads existing config on mount)
  - `BaseButton`: Reusable themed button component
 - Tab navigation (Chat, Calendar, Settings) implemented with themed UI
 - Calendar screen fully functional:
@@ -554,7 +614,7 @@ NODE_ENV=development        # development = pretty logs, production = JSON
  - Orange dot indicator for days with events
  - Tap-to-open modal overlay showing EventCards for selected day
  - Supports events from adjacent months visible in grid
-  - Uses `useFocusEffect` for automatic reload on tab focus
+  - Uses `useFocusEffect` for automatic reload on tab focus with periodic CalDAV sync (10s interval while focused)
  - DeleteEventModal integration for recurring event deletion with three modes
  - EventOverlay hides when DeleteEventModal is open (fixes modal stacking on web)
 - Chat screen fully functional with FlashList, message sending, and event confirm/reject
@@ -570,6 +630,8 @@ NODE_ENV=development        # development = pretty logs, production = JSON
  - keyboardDismissMode="interactive" and keyboardShouldPersistTaps="handled"
 - `EventService`: getAll(), getById(), getByDateRange(), create(), update(), delete(mode, occurrenceDate) - fully implemented with recurring delete modes
 - `ChatService`: sendMessage(), confirmEvent(deleteMode, occurrenceDate), rejectEvent(), getConversations(), getConversation(), updateProposalEvent() - fully implemented with cursor pagination, recurring delete support, and proposal editing
+- `CaldavConfigService`: saveConfig(), getConfig(), deleteConfig(), pull(), pushAll(), sync() - CalDAV config management and sync trigger
+- `CustomTextInput`: Themed text input component with focus border highlight, supports controlled value via `text` prop
 - `CardBase`: Reusable card component with header (title/subtitle), content area, and optional footer button - configurable padding, border, text size via props, ScrollView uses `nestedScrollEnabled` for Android
 - `ModalBase`: Reusable modal wrapper with backdrop (absolute-positioned behind card), uses CardBase internally - provides click-outside-to-close, Android back button support, and proper scrolling on Android
 - `EventCardBase`: Event card with date/time/recurring icons - uses CardBase for structure
--- a/apps/client/src/app/(tabs)/calendar.tsx
+++ b/apps/client/src/app/(tabs)/calendar.tsx
@@ -22,6 +22,7 @@ import { Ionicons } from "@expo/vector-icons";
 import { useThemeStore } from "../../stores/ThemeStore";
 import BaseBackground from "../../components/BaseBackground";
 import { EventService } from "../../services";
+import { CaldavConfigService } from "../../services/CaldavConfigService";
 import { useEventsStore } from "../../stores";
 import { useDropdownPosition } from "../../hooks/useDropdownPosition";

@@ -84,9 +85,15 @@ const Calendar = () => {

  const { events, setEvents, deleteEvent } = useEventsStore();

-  // Function to load events for current view
+  // Sync CalDAV then load events for current view
  const loadEvents = useCallback(async () => {
    try {
+      try {
+        await CaldavConfigService.sync();
+      } catch {
+        // No CalDAV config or sync failed — not critical
+      }
+
      // Calculate first visible day (up to 6 days before month start)
      const firstOfMonth = new Date(currentYear, monthIndex, 1);
      const dayOfWeek = firstOfMonth.getDay();
@@ -122,6 +129,9 @@ const Calendar = () => {
      if (selectedDate) {
        setOverlayVisible(true);
      }
+
+      const interval = setInterval(loadEvents, 10_000);
+      return () => clearInterval(interval);
    }, [loadEvents, selectedDate]),
  );

--- a/apps/client/src/app/(tabs)/settings.tsx
+++ b/apps/client/src/app/(tabs)/settings.tsx
@@ -1,18 +1,106 @@
 import { Text, View } from "react-native";
 import BaseBackground from "../../components/BaseBackground";
-import BaseButton from "../../components/BaseButton";
+import BaseButton, { BaseButtonProps } from "../../components/BaseButton";
 import { useThemeStore } from "../../stores/ThemeStore";
 import { AuthService } from "../../services/AuthService";
 import { router } from "expo-router";
 import { Ionicons } from "@expo/vector-icons";
 import { SimpleHeader } from "../../components/Header";
 import { THEMES } from "../../Themes";
+import CustomTextInput from "../../components/CustomTextInput";
+import { useEffect, useState } from "react";
+import { CaldavConfigService } from "../../services/CaldavConfigService";

 const handleLogout = async () => {
  await AuthService.logout();
  router.replace("/login");
 };

+const SettingsButton = (props: BaseButtonProps) => {
+  return (
+    <BaseButton
+      onPress={props.onPress}
+      solid={props.solid}
+      className={"w-11/12"}
+    >
+      {props.children}
+    </BaseButton>
+  );
+};
+
+type CaldavTextInputProps = {
+  title: string;
+  value: string;
+  onValueChange: (text: string) => void;
+};
+
+const CaldavTextInput = ({ title, value, onValueChange }: CaldavTextInputProps) => {
+  return (
+    <View className="flex flex-row items-center py-1">
+      <Text className="ml-4 w-24">{title}:</Text>
+      <CustomTextInput className="flex-1 mr-4" text={value} onValueChange={onValueChange} />
+    </View>
+  );
+};
+
+const CaldavSettings = () => {
+  const { theme } = useThemeStore();
+
+  const [serverUrl, setServerUrl] = useState("");
+  const [username, setUsername] = useState("");
+  const [password, setPassword] = useState("");
+
+  useEffect(() => {
+    const loadConfig = async () => {
+      try {
+        const config = await CaldavConfigService.getConfig();
+        setServerUrl(config.serverUrl);
+        setUsername(config.username);
+        setPassword(config.password);
+      } catch {
+        // No config saved yet
+      }
+    };
+    loadConfig();
+  }, []);
+
+  const saveConfig = async () => {
+    await CaldavConfigService.saveConfig(serverUrl, username, password);
+  };
+
+  const sync = async () => {
+    await CaldavConfigService.sync();
+  };
+
+  return (
+    <>
+      <View>
+        <Text
+          className="text-center text-2xl"
+          style={{ color: theme.textPrimary }}
+        >
+          Caldav Config
+        </Text>
+      </View>
+      <View>
+        <View className="pb-1">
+          <CaldavTextInput title="url" value={serverUrl} onValueChange={setServerUrl} />
+          <CaldavTextInput title="username" value={username} onValueChange={setUsername} />
+          <CaldavTextInput title="password" value={password} onValueChange={setPassword} />
+        </View>
+        <View className="flex flex-row">
+          <BaseButton className="mx-4 w-1/5" solid={true} onPress={saveConfig}>
+            Save
+          </BaseButton>
+          <BaseButton className="w-1/5" solid={true} onPress={sync}>
+            Sync
+          </BaseButton>
+        </View>
+      </View>
+    </>
+  );
+};
+
 const Settings = () => {
  const { theme, setTheme } = useThemeStore();

@@ -20,10 +108,10 @@ const Settings = () => {
    <BaseBackground>
      <SimpleHeader text="Settings" />
      <View className="flex items-center mt-4">
-        <BaseButton onPress={handleLogout} solid={true}>
+        <SettingsButton onPress={handleLogout} solid={true}>
          <Ionicons name="log-out-outline" size={24} color={theme.primeFg} />{" "}
          Logout
-        </BaseButton>
+        </SettingsButton>
        <View>
          <Text
            className="text-center text-2xl"
@@ -32,23 +120,24 @@ const Settings = () => {
            Select Theme
          </Text>
        </View>
-        <BaseButton
+        <SettingsButton
          solid={theme == THEMES.defaultLight}
          onPress={() => {
            setTheme("defaultLight");
          }}
        >
          Default Light
-        </BaseButton>
-        <BaseButton
+        </SettingsButton>
+        <SettingsButton
          solid={theme == THEMES.defaultDark}
          onPress={() => {
            setTheme("defaultDark");
          }}
        >
          Default Dark
-        </BaseButton>
+        </SettingsButton>
      </View>
+      <CaldavSettings />
    </BaseBackground>
  );
 };
--- a/apps/client/src/app/editEvent.tsx
+++ b/apps/client/src/app/editEvent.tsx
@@ -21,38 +21,27 @@ import { useDropdownPosition } from "../hooks/useDropdownPosition";
 import { EventService, ChatService } from "../services";
 import { buildRRule, CreateEventDTO } from "@calchat/shared";
 import { useChatStore } from "../stores";
+import CustomTextInput, {
+  CustomTextInputProps,
+} from "../components/CustomTextInput";

-type EditEventTextFieldProps = {
+type EditEventTextFieldProps = CustomTextInputProps & {
  titel: string;
-  text?: string;
-  focused?: boolean;
-  className?: string;
-  multiline?: boolean;
-  onValueChange?: (text: string) => void;
 };

 const EditEventTextField = (props: EditEventTextFieldProps) => {
  const { theme } = useThemeStore();
-  const [focused, setFocused] = useState(props.focused ?? false);

  return (
    <View className={props.className}>
      <Text className="text-xl" style={{ color: theme.textPrimary }}>
        {props.titel}
      </Text>
-      <TextInput
-        onChangeText={props.onValueChange}
-        value={props.text}
+      <CustomTextInput
+        className="flex-1"
+        text={props.text}
        multiline={props.multiline}
-        className="flex-1 border border-solid rounded-2xl px-3 py-2 w-full h-11/12"
-        style={{
-          backgroundColor: theme.messageBorderBg,
-          color: theme.textPrimary,
-          textAlignVertical: "top",
-          borderColor: focused ? theme.chatBot : theme.borderPrimary,
-        }}
-        onFocus={() => setFocused(true)}
-        onBlur={() => setFocused(false)}
+        onValueChange={props.onValueChange}
      />
    </View>
  );
--- a/apps/client/src/app/login.tsx
+++ b/apps/client/src/app/login.tsx
@@ -4,6 +4,7 @@ import { Link, router } from "expo-router";
 import BaseBackground from "../components/BaseBackground";
 import AuthButton from "../components/AuthButton";
 import { AuthService } from "../services";
+import { CaldavConfigService } from "../services/CaldavConfigService";
 import { useThemeStore } from "../stores/ThemeStore";

 const LoginScreen = () => {
@@ -24,6 +25,11 @@ const LoginScreen = () => {
    setIsLoading(true);
    try {
      await AuthService.login({ identifier, password });
+      try {
+        await CaldavConfigService.sync();
+      } catch {
+        // No CalDAV config or sync failed — not critical
+      }
      router.replace("/(tabs)/chat");
    } catch {
      setError("Anmeldung fehlgeschlagen. Überprüfe deine Zugangsdaten.");
--- a/apps/client/src/components/AuthGuard.tsx
+++ b/apps/client/src/components/AuthGuard.tsx
@@ -3,6 +3,7 @@ import { View, ActivityIndicator } from "react-native";
 import { Redirect } from "expo-router";
 import { useAuthStore } from "../stores";
 import { useThemeStore } from "../stores/ThemeStore";
+import { CaldavConfigService } from "../services/CaldavConfigService";

 type AuthGuardProps = {
  children: ReactNode;
@@ -20,7 +21,16 @@ export const AuthGuard = ({ children }: AuthGuardProps) => {
  const { isAuthenticated, isLoading, loadStoredUser } = useAuthStore();

  useEffect(() => {
-    loadStoredUser();
+    const init = async () => {
+      await loadStoredUser();
+      if (!useAuthStore.getState().isAuthenticated) return;
+      try {
+        await CaldavConfigService.sync();
+      } catch {
+        // No CalDAV config or sync failed — not critical
+      }
+    };
+    init();
  }, [loadStoredUser]);

  if (isLoading) {
--- a/apps/client/src/components/BaseButton.tsx
+++ b/apps/client/src/components/BaseButton.tsx
@@ -2,17 +2,18 @@ import { Pressable, Text } from "react-native";
 import { useThemeStore } from "../stores/ThemeStore";
 import { ReactNode } from "react";

-type BaseButtonProps = {
+export type BaseButtonProps = {
  children?: ReactNode;
+  className?: string;
  onPress: () => void;
  solid?: boolean;
 };

-const BaseButton = ({ children, onPress, solid = false }: BaseButtonProps) => {
+const BaseButton = ({ className, children, onPress, solid = false }: BaseButtonProps) => {
  const { theme } = useThemeStore();
  return (
    <Pressable
-      className="w-11/12 rounded-lg p-4 mb-4 border-4"
+      className={`rounded-lg p-4 mb-4 border-4 ${className}`}
      onPress={onPress}
      style={{
        borderColor: theme.borderPrimary,
--- a/apps/client/src/components/CustomTextInput.tsx
+++ b/apps/client/src/components/CustomTextInput.tsx
@@ -0,0 +1,35 @@
+import { TextInput } from "react-native";
+import { useThemeStore } from "../stores/ThemeStore";
+import { useState } from "react";
+
+export type CustomTextInputProps = {
+  text?: string;
+  focused?: boolean;
+  className?: string;
+  multiline?: boolean;
+  onValueChange?: (text: string) => void;
+};
+
+const CustomTextInput = (props: CustomTextInputProps) => {
+  const { theme } = useThemeStore();
+  const [focused, setFocused] = useState(props.focused ?? false);
+
+  return (
+    <TextInput
+      className={`border border-solid rounded-2xl px-3 py-2 h-11/12 ${props.className}`}
+      onChangeText={props.onValueChange}
+      value={props.text}
+      multiline={props.multiline}
+      style={{
+        backgroundColor: theme.messageBorderBg,
+        color: theme.textPrimary,
+        textAlignVertical: "top",
+        borderColor: focused ? theme.chatBot : theme.borderPrimary,
+      }}
+      onFocus={() => setFocused(true)}
+      onBlur={() => setFocused(false)}
+    />
+  );
+};
+
+export default CustomTextInput;
--- a/apps/client/src/services/CaldavConfigService.ts
+++ b/apps/client/src/services/CaldavConfigService.ts
@@ -0,0 +1,32 @@
+import { CalendarEvent, CaldavConfig } from "@calchat/shared";
+import { ApiClient } from "./ApiClient";
+
+export const CaldavConfigService = {
+  saveConfig: async (
+    serverUrl: string,
+    username: string,
+    password: string,
+  ): Promise<CaldavConfig> => {
+    return ApiClient.put<CaldavConfig>("/caldav/config", {
+      serverUrl,
+      username,
+      password,
+    });
+  },
+  getConfig: async (): Promise<CaldavConfig> => {
+    return ApiClient.get<CaldavConfig>("/caldav/config");
+  },
+  deleteConfig: async (): Promise<void> => {
+    return ApiClient.delete<void>("/caldav/config");
+  },
+  pull: async (): Promise<CalendarEvent[]> => {
+    return ApiClient.post<CalendarEvent[]>("/caldav/pull");
+  },
+  pushAll: async (): Promise<void> => {
+    return ApiClient.post<void>("/caldav/pushAll");
+  },
+  sync: async (): Promise<void> => {
+    await ApiClient.post<void>("/caldav/pushAll");
+    await ApiClient.post<CalendarEvent[]>("/caldav/pull");
+  },
+};
--- a/apps/server/docker/radicale/docker-compose.yml
+++ b/apps/server/docker/radicale/docker-compose.yml
@@ -0,0 +1,25 @@
+name: Radicale
+services:
+    radicale:
+        image: ghcr.io/kozea/radicale:stable
+        ports:
+        - 5232:5232
+        volumes:
+          - config:/etc/radicale
+          - data:/var/lib/radicale
+
+volumes:
+  config:
+    name: radicale-config
+    driver: local
+    driver_opts:
+      type: none
+      o: bind
+      device: ./config
+  data:
+    name: radicale-data
+    driver: local
+    driver_opts:
+      type: none
+      o: bind
+      device: ./data
--- a/apps/server/jest.config.js
+++ b/apps/server/jest.config.js
@@ -0,0 +1,4 @@
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+};
--- a/apps/server/package.json
+++ b/apps/server/package.json
@@ -5,26 +5,33 @@
  "scripts": {
    "dev": "tsx watch src/app.ts",
    "build": "tsc",
-    "start": "node dist/app.js"
+    "start": "node dist/app.js",
+    "test": "jest"
  },
  "dependencies": {
    "@calchat/shared": "*",
    "bcrypt": "^6.0.0",
    "dotenv": "^16.4.7",
    "express": "^5.2.1",
+    "ical.js": "^2.2.1",
    "jsonwebtoken": "^9.0.3",
    "mongoose": "^9.1.1",
    "openai": "^6.15.0",
    "pino": "^10.1.1",
    "pino-http": "^11.0.0",
-    "rrule": "^2.8.1"
+    "rrule": "^2.8.1",
+    "tsdav": "^2.1.6"
  },
  "devDependencies": {
    "@types/bcrypt": "^6.0.0",
    "@types/express": "^5.0.6",
+    "@types/ical": "^0.8.3",
+    "@types/jest": "^30.0.0",
    "@types/jsonwebtoken": "^9.0.10",
    "@types/node": "^24.10.1",
+    "jest": "^30.2.0",
    "pino-pretty": "^13.1.3",
+    "ts-jest": "^29.4.6",
    "tsx": "^4.21.0",
    "typescript": "^5.9.3"
  }
--- a/apps/server/src/ai/utils/eventFormatter.ts
+++ b/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 };
--- a/apps/server/src/ai/utils/index.ts
+++ b/apps/server/src/ai/utils/index.ts
@@ -1,4 +1,3 @@
-export { formatDate, formatTime, formatDateTime } from "./eventFormatter";
 export { buildSystemPrompt } from "./systemPrompt";
 export {
  TOOL_DEFINITIONS,
--- a/apps/server/src/ai/utils/toolExecutor.ts
+++ b/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.
--- a/apps/server/src/app.ts
+++ b/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
  }),
 );

--- a/apps/server/src/controllers/CaldavController.ts
+++ b/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" });
+    }
+  }
+}
--- a/apps/server/src/controllers/ChatController.ts
+++ b/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(
--- a/apps/server/src/controllers/EventController.ts
+++ b/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");
--- a/apps/server/src/controllers/index.ts
+++ b/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";
--- a/apps/server/src/repositories/mongo/MongoCaldavRepository.ts
+++ b/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;
+  }
+}
--- a/apps/server/src/repositories/mongo/MongoEventRepository.ts
+++ b/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,
--- a/apps/server/src/repositories/mongo/models/CaldavConfigModel.ts
+++ b/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,
+);
--- a/apps/server/src/repositories/mongo/models/EventModel.ts
+++ b/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,
--- a/apps/server/src/routes/caldav.routes.ts
+++ b/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;
+}
--- a/apps/server/src/routes/index.ts
+++ b/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;
 }
--- a/apps/server/src/services/CaldavService.test.ts
+++ b/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);
+// });
--- a/apps/server/src/services/CaldavService.ts
+++ b/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);
+  }
+}
--- a/apps/server/src/services/ChatService.ts
+++ b/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.";
--- a/apps/server/src/services/EventService.ts
+++ b/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,
--- a/apps/server/src/services/interfaces/CaldavRepository.ts
+++ b/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>;
+}
--- a/apps/server/src/services/interfaces/EventRepository.ts
+++ b/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>;
--- a/apps/server/src/utils/eventFormatters.ts
+++ b/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);
--- a/apps/server/src/utils/recurrenceExpander.ts
+++ b/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}`;
-}
--- a/apps/server/tsconfig.json
+++ b/apps/server/tsconfig.json
@@ -8,7 +8,8 @@
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
+    "emitDecoratorMetadata": true,
+    "skipLibCheck": true
  },
  "include": ["src"]
 }
--- a/docs/architecture-class-diagram.puml
+++ b/docs/architecture-class-diagram.puml
@@ -30,6 +30,8 @@ package "Controller Layer" #ADD8E6 {
    }

    class EventController {
+        ' -pushToCaldav()
+        ' -deleteFromCaldav()
        ' +create()
        ' +getById()
        ' +getAll()
@@ -38,6 +40,15 @@ package "Controller Layer" #ADD8E6 {
        ' +delete()
    }

+    class CaldavController {
+        ' +saveConfig()
+        ' +loadConfig()
+        ' +deleteConfig()
+        ' +pullEvents()
+        ' +pushEvents()
+        ' +pushEvent()
+    }
+
    class AuthMiddleware {
        ' +authenticate()
    }
@@ -59,9 +70,12 @@ package "Service Layer" #90EE90 {
            ' +findById()
            ' +findByUserId()
            ' +findByDateRange()
+            ' +findByCaldavUUID()
+            ' +searchByTitle()
            ' +create()
            ' +update()
            ' +delete()
+            ' +addExceptionDate()
        }

        interface ChatRepository {
@@ -69,6 +83,14 @@ package "Service Layer" #90EE90 {
            ' +createConversation()
            ' +getMessages()
            ' +createMessage()
+            ' +updateProposalResponse()
+            ' +updateProposalEvent()
+        }
+
+        interface CaldavRepository {
+            ' +findByUserId()
+            ' +createOrUpdate()
+            ' +deleteByUserId()
        }
    }

@@ -80,7 +102,7 @@ package "Service Layer" #90EE90 {

    class ChatService {
        ' -chatRepo: ChatRepository
-        ' -eventRepo: EventRepository
+        ' -eventService: EventService
        ' -aiProvider: AIProvider
        ' +processMessage()
        ' +confirmEvent()
@@ -95,13 +117,29 @@ package "Service Layer" #90EE90 {
        ' +getById()
        ' +getAll()
        ' +getByDateRange()
+        ' +searchByTitle()
+        ' +findByCaldavUUID()
        ' +update()
        ' +delete()
+        ' +deleteRecurring()
+    }
+
+    class CaldavService {
+        ' -caldavRepo: CaldavRepository
+        ' -eventService: EventService
+        ' +connect()
+        ' +pullEvents()
+        ' +pushEvent()
+        ' +pushAll()
+        ' +deleteEvent()
+        ' +getConfig()
+        ' +saveConfig()
+        ' +deleteConfig()
    }
 }

 package "AI Implementations" #FFA07A {
-    class ClaudeAdapter implements AIProvider {
+    class GPTAdapter implements AIProvider {
        ' -apiKey: string
        ' +processMessage()
    }
@@ -119,6 +157,10 @@ package "Data Access Implementations" #FFD700 {
    class MongoChatRepository implements ChatRepository {
        ' -model: ChatModel
    }
+
+    class MongoCaldavRepository implements CaldavRepository {
+        ' -model: CaldavConfigModel
+    }
 }

 package "Models" #D3D3D3 {
@@ -169,15 +211,20 @@ package "Utils" #DDA0DD {
 ' Controller -> Service
 AuthController --> AuthService
 ChatController --> ChatService
+ChatController --> CaldavService
 EventController --> EventService
+EventController --> CaldavService
+CaldavController --> CaldavService
 AuthMiddleware --> JWT

 ' Service -> Interfaces (intern)
 AuthService --> UserRepository
 ChatService --> ChatRepository
-ChatService --> EventRepository
+ChatService --> EventService
 ChatService --> AIProvider
 EventService --> EventRepository
+CaldavService --> CaldavRepository
+CaldavService --> EventService

 ' Auth uses Utils
 AuthService --> JWT
--- a/docs/component-diagram.puml
+++ b/docs/component-diagram.puml
@@ -16,6 +16,8 @@ package "apps/client (Expo React Native)" as ClientPkg #87CEEB {
        [Login/Register] as AuthScreens
        [Calendar View] as CalendarScreen
        [Chat View] as ChatScreen
+        [Settings] as SettingsScreen
+        [Edit Event] as EditEventScreen
        [Event Detail] as EventDetail
        [Note Editor] as NoteScreen
    }
@@ -25,17 +27,20 @@ package "apps/client (Expo React Native)" as ClientPkg #87CEEB {
        [Auth Service] as ClientAuth
        [Event Service] as ClientEvent
        [Chat Service] as ClientChat
+        [Caldav Config Service] as ClientCaldav
    }

    package "Components" {
        [UI Components] as UIComponents
        [Event Cards] as EventCards
+        [Auth Guard] as AuthGuard
    }

    package "Stores" {
        [Auth Store] as AuthStore
        [Events Store] as EventsStore
        [Chat Store] as ChatStore
+        [Theme Store] as ThemeStore
    }
 }

@@ -59,10 +64,11 @@ package "apps/server (Express.js)" as ServerPkg #98FB98 {
        [AuthService] as AuthSvc
        [ChatService] as ChatSvc
        [EventService] as EventSvc
+        [CaldavService] as CaldavSvc
    }

    package "AI Implementations" {
-        [ClaudeAdapter] as Claude
+        [GPTAdapter] as GPT
    }

    package "Data Access Implementations" {
@@ -80,25 +86,35 @@ package "apps/server (Express.js)" as ServerPkg #98FB98 {

 ' ===== ROW 4: EXTERNAL =====
 database "MongoDB" as MongoDB
-cloud "Claude API" as ClaudeAPI
+cloud "OpenAI API" as OpenAIAPI
+cloud "CalDAV Server" as CaldavServer

 ' ===== CONNECTIONS =====

 ' Frontend: Screens -> Services
 AuthScreens --> ClientAuth
 CalendarScreen --> ClientEvent
+CalendarScreen --> ClientCaldav
 ChatScreen --> ClientChat
+SettingsScreen --> ClientCaldav
+EditEventScreen --> ClientEvent
 EventDetail --> ClientEvent
 NoteScreen --> ClientEvent

 ClientAuth --> ApiClient
 ClientEvent --> ApiClient
 ClientChat --> ApiClient
+ClientCaldav --> ApiClient

 ApiClient --> AuthStore
 ClientEvent --> EventsStore
 ClientChat --> ChatStore

+' Frontend: Auth
+AuthGuard --> AuthStore
+AuthGuard --> ClientCaldav
+AuthScreens --> ClientCaldav
+
 ' Frontend: Screens -> Components
 CalendarScreen --> EventCards
 ChatScreen --> EventCards
@@ -121,14 +137,20 @@ Routes --> Controllers
 Controllers --> AuthSvc
 Controllers --> ChatSvc
 Controllers --> EventSvc
+Controllers --> CaldavSvc

 ' Backend: Service -> Interfaces
 AuthSvc --> Interfaces
 ChatSvc --> Interfaces
 EventSvc --> Interfaces
+CaldavSvc --> Interfaces
+
+' Backend: Service dependencies
+ChatSvc --> EventSvc
+CaldavSvc --> EventSvc

 ' Backend: AI & Data Access implement Interfaces
-Claude ..|> Interfaces
+GPT ..|> Interfaces
 Repos ..|> Interfaces

 ' Backend: Service -> Utils
@@ -143,6 +165,7 @@ Repos --> Schemas

 ' Backend -> External
 Schemas --> MongoDB
-Claude --> ClaudeAPI
+GPT --> OpenAIAPI
+CaldavSvc --> CaldavServer

@enduml
--- a/docs/frontend-class-diagram.puml
+++ b/docs/frontend-class-diagram.puml
@@ -22,18 +22,26 @@ package "Screens" #87CEEB {
    class RegisterScreen
    class CalendarScreen
    class ChatScreen
+    class SettingsScreen
+    class EditEventScreen
    class EventDetailScreen
    class NoteScreen
 }

 ' ===== COMPONENTS =====
 package "Components" #FFA07A  {
+    class AuthGuard
    class BaseBackground
    class Header
+    class BaseButton
+    class CardBase
+    class ModalBase
    class EventCardBase
    class EventCard
    class ProposedEventCard
-    class EventConfirmDialog
+    class DeleteEventModal
+    class ChatBubble
+    class TypingIndicator
 }

 ' ===== SERVICES =====
@@ -64,6 +72,13 @@ package "Services" #90EE90 {
        +rejectEvent()
        +getConversations()
        +getConversation()
+        +updateProposalEvent()
+    }
+    class CaldavConfigService {
+        +getConfig()
+        +saveConfig()
+        +deleteConfig()
+        +sync()
    }
 }

@@ -71,11 +86,10 @@ package "Services" #90EE90 {
 package "Stores" #FFD700 {
    class AuthStore {
        ' +user
-        ' +token
        ' +isAuthenticated
        ' +login()
        ' +logout()
-        ' +setToken()
+        ' +loadStoredUser()
    }
    class EventsStore {
        ' +events
@@ -86,10 +100,16 @@ package "Stores" #FFD700 {
    }
    class ChatStore {
        ' +messages
+        ' +isWaitingForResponse
        ' +addMessage()
+        ' +addMessages()
        ' +updateMessage()
        ' +clearMessages()
    }
+    class ThemeStore {
+        ' +theme
+        ' +setTheme()
+    }
 }

 ' ===== MODELS =====
@@ -97,6 +117,7 @@ package "Models (shared)" #D3D3D3 {
    class User
    class CalendarEvent
    class ChatMessage
+    class CaldavConfig
 }

 ' ===== RELATIONSHIPS =====
@@ -104,24 +125,39 @@ package "Models (shared)" #D3D3D3 {
 ' Screens -> Services
 LoginScreen --> AuthService
 CalendarScreen --> EventService
+CalendarScreen --> CaldavConfigService
 ChatScreen --> ChatService
 NoteScreen --> EventService
+EditEventScreen --> EventService
+EditEventScreen --> ChatService
+SettingsScreen --> CaldavConfigService

 ' Screens -> Components
 CalendarScreen --> EventCard
 ChatScreen --> ProposedEventCard
-ChatScreen --> EventConfirmDialog
+ChatScreen --> ChatBubble
+ChatScreen --> TypingIndicator
 EventCard --> EventCardBase
 ProposedEventCard --> EventCardBase
+EventCardBase --> CardBase
+ModalBase --> CardBase
+DeleteEventModal --> ModalBase
+
+' Auth
+AuthGuard --> AuthStore
+AuthGuard --> CaldavConfigService
+LoginScreen --> CaldavConfigService

 ' Services -> ApiClient
 AuthService --> ApiClient
 EventService --> ApiClient
 ChatService --> ApiClient
+CaldavConfigService --> ApiClient

 ' Services/Screens -> Stores
 AuthService --> AuthStore
-EventService --> EventsStore
+CalendarScreen --> EventsStore
 ChatScreen --> ChatStore
+SettingsScreen --> ThemeStore

@enduml
--- a/package-lock.json
+++ b/package-lock.json
--- a/packages/shared/src/models/CaldavConfig.ts
+++ b/packages/shared/src/models/CaldavConfig.ts
@@ -0,0 +1,7 @@
+export interface CaldavConfig {
+  userId: string;
+  serverUrl: string;
+  username: string;
+  password: string;
+  syncIntervalSeconds?: number;
+}
--- a/packages/shared/src/models/CalendarEvent.ts
+++ b/packages/shared/src/models/CalendarEvent.ts
@@ -1,6 +1,8 @@
 export interface CalendarEvent {
  id: string;
  userId: string;
+  caldavUUID?: string;
+  etag?: string;
  title: string;
  description?: string;
  startTime: Date;
@@ -10,9 +12,11 @@ export interface CalendarEvent {
  exceptionDates?: string[]; // ISO date strings (YYYY-MM-DD) for excluded occurrences
  createdAt?: Date;
  updatedAt?: Date;
+  caldavSyncStatus?: CaldavSyncStatus;
 }

 export type RecurringDeleteMode = "single" | "future" | "all";
+export type CaldavSyncStatus = "synced" | "error";

 export interface DeleteRecurringEventDTO {
  mode: RecurringDeleteMode;
@@ -20,6 +24,8 @@ export interface DeleteRecurringEventDTO {
 }

 export interface CreateEventDTO {
+  caldavUUID?: string;
+  etag?: string;
  title: string;
  description?: string;
  startTime: Date;
@@ -27,9 +33,12 @@ export interface CreateEventDTO {
  note?: string;
  recurrenceRule?: string;
  exceptionDates?: string[]; // For display in proposals
+  caldavSyncStatus?: CaldavSyncStatus;
 }

 export interface UpdateEventDTO {
+  caldavUUID?: string;
+  etag?: string;
  title?: string;
  description?: string;
  startTime?: Date;
@@ -37,6 +46,7 @@ export interface UpdateEventDTO {
  note?: string;
  recurrenceRule?: string;
  exceptionDates?: string[];
+  caldavSyncStatus?: CaldavSyncStatus;
 }

 export interface ExpandedEvent extends CalendarEvent {
--- a/packages/shared/src/models/index.ts
+++ b/packages/shared/src/models/index.ts
@@ -2,3 +2,4 @@ export * from "./User";
 export * from "./CalendarEvent";
 export * from "./ChatMessage";
 export * from "./Constants";
+export * from "./CaldavConfig";
--- a/packages/shared/src/utils/formatters.ts
+++ b/packages/shared/src/utils/formatters.ts
@@ -69,3 +69,11 @@ export function formatDateWithWeekdayShort(date: Date): string {
    month: "2-digit",
  });
 }
+
+// Format date as YYYY-MM-DD for exception date comparison
+export 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}`;
+}