@cachly-dev/mcp-server 0.10.64 → 0.10.66

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

@@ -1,112 +0,0 @@
-/**
- * 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

@@ -1,145 +0,0 @@
-/**
- * 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

@@ -1,43 +0,0 @@
-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

@@ -1,28 +0,0 @@
-/**
- * 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

@@ -1,44 +0,0 @@
-/**
- * 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);
-}