@cachly-dev/mcp-server 0.10.48 → 0.10.49

package/apps/travel-chaos-organizer/frontend/lib/notifications.ts

@@ -0,0 +1,112 @@
+/**
+ * Trip reminder notifications.
+ * Schedules a local push 24 hours before trip start_date.
+ * Requires expo-notifications (added to app.config plugins).
+ */
+import * as Notifications from "expo-notifications";
+import { Platform } from "react-native";
+
+Notifications.setNotificationHandler({
+  handleNotification: async () => ({
+    shouldShowAlert: true,
+    shouldPlaySound: true,
+    shouldSetBadge: false,
+  }),
+});
+
+export async function requestNotificationPermission(): Promise<boolean> {
+  const { status: existing } = await Notifications.getPermissionsAsync();
+  if (existing === "granted") return true;
+  const { status } = await Notifications.requestPermissionsAsync();
+  return status === "granted";
+}
+
+export async function scheduleTripReminder(tripId: string, tripName: string, startDate: string): Promise<void> {
+  const granted = await requestNotificationPermission();
+  if (!granted) return;
+
+  const start = new Date(startDate);
+  const reminderTime = new Date(start.getTime() - 24 * 60 * 60 * 1000);
+  if (reminderTime <= new Date()) return;
+
+  // Cancel existing reminder for this trip before re-scheduling
+  await cancelTripReminder(tripId);
+
+  await Notifications.scheduleNotificationAsync({
+    identifier: `trip-${tripId}`,
+    content: {
+      title: `✈️ Morgen geht's los!`,
+      body: `${tripName} startet morgen. Alles gepackt?`,
+      data: { tripId },
+    },
+    trigger: {
+      type: Notifications.SchedulableTriggerInputTypes.DATE,
+      date: reminderTime,
+    },
+  });
+}
+
+export async function cancelTripReminder(tripId: string): Promise<void> {
+  await Notifications.cancelScheduledNotificationAsync(`trip-${tripId}`).catch(() => {});
+}
+
+export async function scheduleAllTripReminders(trips: { id: string; name: string; start_date: string | null }[]): Promise<void> {
+  for (const trip of trips) {
+    if (trip.start_date) {
+      await scheduleTripReminder(trip.id, trip.name, trip.start_date);
+    }
+  }
+}
+
+export async function scheduleItemReminder(
+  tripId: string,
+  tripName: string,
+  itemId: string,
+  itemTitle: string,
+  eventAt: string,
+): Promise<void> {
+  const granted = await requestNotificationPermission();
+  if (!granted) return;
+
+  await cancelItemReminders(itemId);
+
+  const event = new Date(eventAt);
+  const now = new Date();
+
+  const reminder24h = new Date(event.getTime() - 24 * 60 * 60 * 1000);
+  if (reminder24h > now) {
+    await Notifications.scheduleNotificationAsync({
+      identifier: `item-${itemId}-24h`,
+      content: {
+        title: `⏰ ${itemTitle}`,
+        body: `Morgen: ${itemTitle} — ${tripName}`,
+        data: { tripId, itemId },
+      },
+      trigger: {
+        type: Notifications.SchedulableTriggerInputTypes.DATE,
+        date: reminder24h,
+      },
+    });
+  }
+
+  const reminder2h = new Date(event.getTime() - 2 * 60 * 60 * 1000);
+  if (reminder2h > now) {
+    await Notifications.scheduleNotificationAsync({
+      identifier: `item-${itemId}-2h`,
+      content: {
+        title: `🔔 In 2 Stunden: ${itemTitle}`,
+        body: `${itemTitle} startet bald. Alles bereit?`,
+        data: { tripId, itemId },
+      },
+      trigger: {
+        type: Notifications.SchedulableTriggerInputTypes.DATE,
+        date: reminder2h,
+      },
+    });
+  }
+}
+
+export async function cancelItemReminders(itemId: string): Promise<void> {
+  await Notifications.cancelScheduledNotificationAsync(`item-${itemId}-24h`).catch(() => {});
+  await Notifications.cancelScheduledNotificationAsync(`item-${itemId}-2h`).catch(() => {});
+}

package/apps/travel-chaos-organizer/frontend/lib/offlineQueue.ts

@@ -0,0 +1,145 @@
+/**
+ * Offline mutation queue — persists pending creates/updates in SQLite.
+ * Drains automatically when network returns.
+ *
+ * Pattern: same as cachly's "never lose a write" approach — buffer locally,
+ * replay in order when the API is reachable again.
+ */
+import * as SQLite from "expo-sqlite";
+import * as Network from "expo-network";
+import { ApiError } from "./api";
+
+const db = SQLite.openDatabaseSync("tco.db");
+
+export type QueuedOp = {
+  id: number;
+  method: "POST" | "PATCH" | "DELETE";
+  path: string;
+  body: string | null;
+  created_at: number;
+  retries: number;
+};
+
+export function initQueue(): void {
+  db.execSync(`
+    CREATE TABLE IF NOT EXISTS offline_queue (
+      id         INTEGER PRIMARY KEY AUTOINCREMENT,
+      method     TEXT NOT NULL,
+      path       TEXT NOT NULL,
+      body       TEXT,
+      created_at INTEGER NOT NULL,
+      retries    INTEGER NOT NULL DEFAULT 0
+    );
+  `);
+}
+
+export function enqueue(method: QueuedOp["method"], path: string, body?: object): void {
+  db.runSync(
+    "INSERT INTO offline_queue (method, path, body, created_at) VALUES (?, ?, ?, ?)",
+    [method, path, body ? JSON.stringify(body) : null, Date.now()]
+  );
+}
+
+export function getPending(): QueuedOp[] {
+  return db.getAllSync<QueuedOp>("SELECT * FROM offline_queue ORDER BY id ASC");
+}
+
+export function dequeue(id: number): void {
+  db.runSync("DELETE FROM offline_queue WHERE id = ?", [id]);
+}
+
+export function incrementRetry(id: number): void {
+  db.runSync("UPDATE offline_queue SET retries = retries + 1 WHERE id = ?", [id]);
+}
+
+// Ops that have failed > 5 times are discarded — avoids infinite poison-pill loops
+export function purgeFailed(maxRetries = 5): void {
+  db.runSync("DELETE FROM offline_queue WHERE retries >= ?", [maxRetries]);
+}
+
+export let onQueueError: ((count: number) => void) | null = null;
+
+export function setQueueErrorCallback(cb: (count: number) => void): void {
+  onQueueError = cb;
+}
+
+/** Alias used by api.ts — enqueue a failed mutation for later replay. */
+export function enqueueRequest(method: QueuedOp["method"], path: string, body?: object): void {
+  enqueue(method, path, body);
+}
+
+/** Alias used by useNetworkSync — drain the queue using stored auth. */
+export async function processQueue(
+  authHeaders: () => Promise<Record<string, string>>,
+  baseUrl: string
+): Promise<{ succeeded: number; failed: number }> {
+  return drainQueue(authHeaders, baseUrl);
+}
+
+export async function drainQueue(
+  authHeaders: () => Promise<Record<string, string>>,
+  baseUrl: string
+): Promise<{ succeeded: number; failed: number }> {
+  const net = await Network.getNetworkStateAsync();
+  if (!net.isConnected) return { succeeded: 0, failed: 0 };
+
+  purgeFailed();
+  const ops = getPending();
+  let succeeded = 0;
+  let failed = 0;
+
+  const headers = await authHeaders();
+  let permanentlyRemoved = 0;
+
+  for (const op of ops) {
+    try {
+      const res = await fetch(`${baseUrl}${op.path}`, {
+        method: op.method,
+        headers: { ...headers, "Content-Type": "application/json" },
+        body: op.body ?? undefined,
+      });
+      if (res.ok || res.status === 404) {
+        dequeue(op.id);
+        succeeded++;
+      } else if (res.status === 429) {
+        incrementRetry(op.id);
+        failed++;
+      } else if (res.status >= 400 && res.status < 500) {
+        dequeue(op.id);
+        permanentlyRemoved++;
+        failed++;
+      } else {
+        incrementRetry(op.id);
+        failed++;
+      }
+    } catch (err) {
+      if (err instanceof ApiError) {
+        if (err.status === 401 || err.status === 403) {
+          console.warn(`offlineQueue: removing unrecoverable op ${op.id} (${err.status})`);
+          dequeue(op.id);
+          permanentlyRemoved++;
+          failed++;
+        } else if (err.status === 429 || err.status == null) {
+          incrementRetry(op.id);
+          failed++;
+        } else if (err.status >= 400 && err.status < 500) {
+          dequeue(op.id);
+          permanentlyRemoved++;
+          failed++;
+        } else {
+          incrementRetry(op.id);
+          failed++;
+        }
+      } else {
+        incrementRetry(op.id);
+        failed++;
+      }
+    }
+  }
+
+  if (permanentlyRemoved > 0) {
+    onQueueError?.(permanentlyRemoved);
+  }
+
+  return { succeeded, failed };
+}

package/apps/travel-chaos-organizer/frontend/lib/quota.tsx

@@ -0,0 +1,43 @@
+import React, { createContext, useContext, useEffect, useState, useCallback } from "react";
+import { usersApi, UserPlan } from "./api";
+
+type QuotaCtx = {
+  plan: UserPlan | null;
+  isPro: boolean;
+  error: string | null;
+  refresh: () => Promise<void>;
+};
+
+const QuotaContext = createContext<QuotaCtx>({
+  plan: null,
+  isPro: false,
+  error: null,
+  refresh: async () => {},
+});
+
+export function QuotaProvider({ children }: { children: React.ReactNode }) {
+  const [plan, setPlan] = useState<UserPlan | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const refresh = useCallback(async () => {
+    try {
+      const p = await usersApi.me();
+      setPlan(p);
+      setError(null);
+    } catch {
+      setError('Quota-Status konnte nicht geladen werden');
+    }
+  }, []);
+
+  useEffect(() => { refresh(); }, [refresh]);
+
+  return (
+    <QuotaContext.Provider value={{ plan, isPro: plan?.is_pro ?? false, error, refresh }}>
+      {children}
+    </QuotaContext.Provider>
+  );
+}
+
+export function useQuota() {
+  return useContext(QuotaContext);
+}

package/apps/travel-chaos-organizer/frontend/lib/sentry.ts

@@ -0,0 +1,28 @@
+/**
+ * Sentry integration — no-op when EXPO_PUBLIC_SENTRY_DSN is not set.
+ * Call initSentry() once at app startup.
+ */
+
+export function initSentry(): void {
+  const dsn = process.env.EXPO_PUBLIC_SENTRY_DSN;
+  if (!dsn) return;
+
+  // Lazy import to avoid bundling Sentry when not configured
+  import("@sentry/react-native").then((Sentry) => {
+    const integrations = typeof (Sentry as any).reactNativeTracingIntegration === "function"
+      ? [(Sentry as any).reactNativeTracingIntegration()]
+      : [];
+    Sentry.init({
+      dsn,
+      tracesSampleRate: 0.1,
+      integrations,
+      environment: __DEV__ ? "development" : "production",
+    });
+  }).catch(() => undefined);
+}
+
+export function captureException(err: unknown): void {
+  const dsn = process.env.EXPO_PUBLIC_SENTRY_DSN;
+  if (!dsn) return;
+  import("@sentry/react-native").then(({ captureException: cap }) => cap(err as Error)).catch(() => undefined);
+}

package/apps/travel-chaos-organizer/frontend/lib/shareIntent.ts

@@ -0,0 +1,44 @@
+/**
+ * Share intent handler — receives files/URLs shared into the app via the tco:// scheme.
+ * Works in managed Expo workflow via Linking. Full native share sheets (iOS share extension,
+ * Android intent filters) require ejecting or a custom plugin; this handles deep links only.
+ */
+import * as Linking from "expo-linking";
+
+export type SharedFile = {
+  uri: string;
+  mimeType: string;
+  name: string;
+};
+
+/** Parse a tco://share?uri=...&mime=...&name=... deep link into a SharedFile. */
+export function parseShareLink(url: string): SharedFile | null {
+  try {
+    const parsed = Linking.parse(url);
+    const uri = parsed.queryParams?.uri as string | undefined;
+    const mime = (parsed.queryParams?.mime as string | undefined) ?? "application/octet-stream";
+    const name = (parsed.queryParams?.name as string | undefined) ?? "shared-file";
+    if (!uri) return null;
+    return { uri, mimeType: mime, name };
+  } catch {
+    return null;
+  }
+}
+
+/** Subscribe to incoming share links. Returns an unsubscribe function. */
+export function onShareIntent(handler: (file: SharedFile) => void): () => void {
+  const sub = Linking.addEventListener("url", ({ url }) => {
+    if (url.startsWith("tco://share")) {
+      const file = parseShareLink(url);
+      if (file) handler(file);
+    }
+  });
+  return () => sub.remove();
+}
+
+/** Check if the app was launched from a share intent. */
+export async function getInitialShareIntent(): Promise<SharedFile | null> {
+  const url = await Linking.getInitialURL();
+  if (!url || !url.startsWith("tco://share")) return null;
+  return parseShareLink(url);
+}