feat: self-host Hobbs Family Organizer (Shield TV dashboard) on hf-pdocker-02:8340

- tv app/Hobbs-Family-Organizer-Self-Hosted-v1.0.0: release bundle (Next.js app + Shield APK v1.4 + source) - compose/hf-pdocker-02/hobbs-organizer: override (local-disk secrets, watchtower off), .env (port 8340), Shield provisioning script - CLAUDE.md: service tree + internal ports Trusted-LAN mode. Secrets live only on .100 /var/lib/hobbs-organizer/secrets (not in git). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01E9NnVEico3WvFxLyjy1iW3
2026-11-04 18:27:22 -06:00
parent 122ea392d1
commit e9c7e9df1a
68 changed files with 12831 additions and 0 deletions
@@ -0,0 +1,297 @@
+import ICAL from "ical.js";
+
+type CalendarTone = "cyan" | "amber" | "violet" | "emerald" | "rose";
+
+type CalendarEvent = {
+  id: string;
+  calendar: string;
+  title: string;
+  location?: string;
+  start: string;
+  end: string;
+  allDay: boolean;
+  tone: CalendarTone;
+};
+
+const tones: CalendarTone[] = ["cyan", "amber", "violet", "emerald", "rose"];
+const maxFeedBytes = 5 * 1024 * 1024;
+const maxOccurrencesPerEvent = 10_000;
+
+export const dynamic = "force-dynamic";
+
+function cleanText(value: unknown, fallback: string, maxLength: number) {
+  return String(value ?? fallback).replace(/\s+/g, " ").trim().slice(0, maxLength) || fallback;
+}
+
+function calendarDate(value: ICAL.Time) {
+  return `${String(value.year).padStart(4, "0")}-${String(value.month).padStart(2, "0")}-${String(value.day).padStart(2, "0")}`;
+}
+
+function organizerDate(date: Date) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: process.env.ORGANIZER_TIMEZONE || "America/Chicago",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(date);
+  const value = (part: string) => parts.find((entry) => entry.type === part)?.value ?? "";
+  return `${value("year")}-${value("month")}-${value("day")}`;
+}
+
+function addCalendarDays(isoDate: string, days: number) {
+  const [year, month, day] = isoDate.split("-").map(Number);
+  const value = new Date(Date.UTC(year, month - 1, day + days));
+  return value.toISOString().slice(0, 10);
+}
+
+function hashId(value: string) {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0).toString(36);
+}
+
+function parseFeedUrls() {
+  const raw = process.env.CALENDAR_ICAL_URLS;
+  if (!raw) return [];
+
+  const values = JSON.parse(raw) as unknown;
+  if (!Array.isArray(values) || values.length < 1 || values.length > 10) {
+    throw new Error("Calendar feed configuration is invalid");
+  }
+
+  return values.map((value) => {
+    const url = new URL(String(value));
+    if (url.protocol !== "https:" || url.hostname !== "calendar.google.com" || !url.pathname.endsWith("/basic.ics")) {
+      throw new Error("Calendar feed host is not allowed");
+    }
+    return url.toString();
+  });
+}
+
+async function readLimitedText(response: Response) {
+  const declaredLength = Number(response.headers.get("content-length") ?? 0);
+  if (declaredLength > maxFeedBytes) throw new Error("Calendar feed is too large");
+  if (!response.body) return "";
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let total = 0;
+  let text = "";
+
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    total += chunk.value.byteLength;
+    if (total > maxFeedBytes) {
+      await reader.cancel();
+      throw new Error("Calendar feed is too large");
+    }
+    text += decoder.decode(chunk.value, { stream: true });
+  }
+
+  return text + decoder.decode();
+}
+
+function componentString(component: ICAL.Component, name: string) {
+  const value = component.getFirstPropertyValue(name);
+  return typeof value === "string" ? value : "";
+}
+
+function isCancelled(event: ICAL.Event) {
+  return componentString(event.component, "status").toUpperCase() === "CANCELLED";
+}
+
+function detach(component: ICAL.Component) {
+  return new ICAL.Component(structuredClone(component.toJSON()));
+}
+
+function eventIsInWindow(
+  start: ICAL.Time,
+  end: ICAL.Time,
+  windowStart: number,
+  horizon: number,
+  windowStartDate: string,
+  horizonDate: string,
+) {
+  if (start.isDate) {
+    return calendarDate(end) > windowStartDate && calendarDate(start) <= horizonDate;
+  }
+  return end.toJSDate().getTime() > windowStart && start.toJSDate().getTime() <= horizon;
+}
+
+function occurrenceIsPastHorizon(start: ICAL.Time, horizon: number, horizonDate: string) {
+  return start.isDate ? calendarDate(start) > horizonDate : start.toJSDate().getTime() > horizon;
+}
+
+function serializeOccurrence(
+  event: ICAL.Event,
+  start: ICAL.Time,
+  end: ICAL.Time,
+  calendar: string,
+  tone: CalendarTone,
+  feedIndex: number,
+) {
+  const allDay = start.isDate;
+  const startValue = allDay ? calendarDate(start) : start.toJSDate().toISOString();
+  const endValue = allDay ? calendarDate(end) : end.toJSDate().toISOString();
+  const uid = cleanText(event.uid, "event", 180);
+  const location = cleanText(event.location, "", 120);
+
+  return {
+    id: hashId(`${feedIndex}|${uid}|${startValue}`),
+    calendar,
+    title: cleanText(event.summary, "Busy", 140),
+    ...(location ? { location } : {}),
+    start: startValue,
+    end: endValue,
+    allDay,
+    tone,
+  } satisfies CalendarEvent;
+}
+
+function expandCalendar(
+  ics: string,
+  feedIndex: number,
+  windowStart: number,
+  horizon: number,
+  windowStartDate: string,
+  horizonDate: string,
+) {
+  const root = new ICAL.Component(ICAL.parse(ics));
+  for (const timezone of root.getAllSubcomponents("vtimezone")) {
+    try {
+      ICAL.TimezoneService.register(timezone);
+    } catch {
+      // A feed may repeat a timezone that was already registered.
+    }
+  }
+
+  const sourceName = cleanText(root.getFirstPropertyValue("x-wr-calname"), `Calendar ${feedIndex + 1}`, 50);
+  const calendar = sourceName.includes("@") ? "Personal" : sourceName;
+  const tone = tones[feedIndex % tones.length];
+  const components = root.getAllSubcomponents("vevent");
+  const exceptions = new Map<string, ICAL.Component[]>();
+
+  for (const component of components) {
+    if (!component.hasProperty("recurrence-id")) continue;
+    const uid = componentString(component, "uid");
+    if (!uid) continue;
+    exceptions.set(uid, [...(exceptions.get(uid) ?? []), component]);
+  }
+
+  const items: CalendarEvent[] = [];
+  for (const component of components) {
+    if (component.hasProperty("recurrence-id")) continue;
+
+    try {
+      const event = new ICAL.Event(detach(component));
+      for (const exception of exceptions.get(event.uid) ?? []) {
+        event.relateException(detach(exception));
+      }
+      if (isCancelled(event)) continue;
+
+      if (!event.isRecurring()) {
+        if (eventIsInWindow(event.startDate, event.endDate, windowStart, horizon, windowStartDate, horizonDate)) {
+          items.push(serializeOccurrence(event, event.startDate, event.endDate, calendar, tone, feedIndex));
+        }
+        continue;
+      }
+
+      const iterator = event.iterator();
+      for (let count = 0; count < maxOccurrencesPerEvent; count += 1) {
+        const occurrence = iterator.next();
+        if (!occurrence) break;
+        if (occurrenceIsPastHorizon(occurrence, horizon, horizonDate)) break;
+
+        const details = event.getOccurrenceDetails(occurrence);
+        if (isCancelled(details.item)) continue;
+        if (eventIsInWindow(details.startDate, details.endDate, windowStart, horizon, windowStartDate, horizonDate)) {
+          items.push(serializeOccurrence(details.item, details.startDate, details.endDate, calendar, tone, feedIndex));
+        }
+      }
+    } catch {
+      // Ignore a malformed event while keeping the rest of the calendar usable.
+    }
+  }
+
+  return { calendar, items };
+}
+
+async function readCalendar(
+  url: string,
+  feedIndex: number,
+  windowStart: number,
+  horizon: number,
+  windowStartDate: string,
+  horizonDate: string,
+) {
+  let currentUrl = url;
+  let response: Response | undefined;
+  for (let redirectCount = 0; redirectCount <= 3; redirectCount += 1) {
+    const validatedUrl = new URL(currentUrl);
+    if (validatedUrl.protocol !== "https:" || validatedUrl.hostname !== "calendar.google.com" || !validatedUrl.pathname.endsWith("/basic.ics")) {
+      throw new Error("Calendar redirect host is not allowed");
+    }
+    response = await fetch(validatedUrl, {
+      headers: { Accept: "text/calendar" },
+      redirect: "manual",
+      signal: AbortSignal.timeout(10_000),
+    });
+    if (![301, 302, 303, 307, 308].includes(response.status)) break;
+    const location = response.headers.get("location");
+    if (!location || redirectCount === 3) throw new Error("Calendar feed redirected too many times");
+    currentUrl = new URL(location, validatedUrl).toString();
+  }
+  if (!response) throw new Error("Calendar feed request failed");
+  if (!response.ok) throw new Error("Calendar feed request failed");
+  return expandCalendar(await readLimitedText(response), feedIndex, windowStart, horizon, windowStartDate, horizonDate);
+}
+
+export async function GET() {
+  let urls: string[];
+  try {
+    urls = parseFeedUrls();
+  } catch {
+    return Response.json({ items: [], calendarsAvailable: 0, calendarsTotal: 0, updatedAt: new Date().toISOString() }, { status: 503 });
+  }
+
+  if (!urls.length) {
+    return Response.json({ items: [], calendarsAvailable: 0, calendarsTotal: 0, updatedAt: new Date().toISOString() }, { status: 503 });
+  }
+
+  const now = Date.now();
+  const windowStart = now - 45 * 24 * 60 * 60 * 1_000;
+  const horizon = now + 60 * 24 * 60 * 60 * 1_000;
+  const today = organizerDate(new Date(now));
+  const windowStartDate = addCalendarDays(today, -45);
+  const horizonDate = addCalendarDays(today, 60);
+  const results = await Promise.allSettled(
+    urls.map((url, index) => readCalendar(url, index, windowStart, horizon, windowStartDate, horizonDate)),
+  );
+  const successful = results.filter((result): result is PromiseFulfilledResult<Awaited<ReturnType<typeof readCalendar>>> => result.status === "fulfilled");
+  const items = successful
+    .flatMap((result) => result.value.items)
+    .filter((item, index, all) => all.findIndex((candidate) => candidate.id === item.id) === index)
+    .sort((left, right) => {
+      const leftValue = left.allDay ? `${left.start}T00:00:00` : left.start;
+      const rightValue = right.allDay ? `${right.start}T00:00:00` : right.start;
+      return leftValue.localeCompare(rightValue);
+    })
+    .slice(0, 160);
+
+  return Response.json(
+    {
+      items,
+      calendarsAvailable: successful.length,
+      calendarsTotal: urls.length,
+      updatedAt: new Date().toISOString(),
+    },
+    {
+      status: successful.length ? 200 : 503,
+      headers: { "Cache-Control": "private, max-age=60, stale-while-revalidate=240" },
+    },
+  );
+}