@knotpad/app 0.1.4 → 0.1.6

package/lib/calendar-feed.ts

@@ -0,0 +1,239 @@
+/**
+ * Core sync logic for read-only calendar feed import.
+ *
+ * Fetches a user's .ics subscription URL, parses VEVENTs (expanding RRULE
+ * recurrences within a fixed past/future window), and caches the result as
+ * CalendarFeedEvent rows. Never throws — failures are recorded on
+ * CalendarFeed.lastError so the cron loop / on-demand sync can report
+ * cleanly without surfacing internals (e.g. the URL) to the client.
+ */
+
+// Dynamic import: node-ical pulls in temporal-polyfill which uses BigInt at
+// module-evaluation time.  A static import breaks Turbopack's server bundle
+// ("s.BigInt is not a function") during `next build` page-data collection.
+import type * as icalNS from "node-ical";
+import { prisma } from "@/lib/prisma";
+import { decryptFeedUrl } from "@/lib/calendar-feed-crypto";
+import {
+  ICS_FETCH_TIMEOUT_MS,
+  ICS_MAX_BYTES,
+  CALENDAR_FEED_PAST_DAYS,
+  CALENDAR_FEED_FUTURE_DAYS,
+} from "@/lib/limits";
+
+function summaryText(v: icalNS.ParameterValue<string> | undefined): string {
+  if (!v) return "Untitled event";
+  const text = typeof v === "string" ? v : v.val;
+  return text || "Untitled event";
+}
+
+function isDateExcluded(exdate: Date | Date[] | Record<string, Date> | undefined, date: Date): boolean {
+  if (!exdate) return false;
+  const targetTime = date.getTime();
+  if (exdate instanceof Date) {
+    return exdate.getTime() === targetTime;
+  }
+  if (Array.isArray(exdate)) {
+    return exdate.some((d) => d instanceof Date && d.getTime() === targetTime);
+  }
+  if (typeof exdate === "object") {
+    return Object.values(exdate).some((d) => d instanceof Date && d.getTime() === targetTime);
+  }
+  return false;
+}
+
+type EventRow = { uid: string; title: string; start: Date; end: Date; allDay: boolean };
+
+export async function fetchAndCacheFeed(feedId: string): Promise<{ ok: boolean; error?: string }> {
+  const feed = await prisma.calendarFeed.findUnique({ where: { id: feedId } });
+  if (!feed) return { ok: false, error: "Feed not found" };
+
+  let url: string;
+  try {
+    url = await decryptFeedUrl(feed.encryptedUrl, feed.urlSalt);
+  } catch {
+    await prisma.calendarFeed.update({
+      where: { id: feedId },
+      data: { lastError: "Failed to decrypt feed URL" },
+    });
+    return { ok: false, error: "Failed to decrypt feed URL" };
+  }
+
+  let text: string;
+  try {
+    text = await fetchIcsBody(url);
+  } catch (err) {
+    const message =
+      err instanceof Error && err.name === "AbortError"
+        ? "Feed request timed out"
+        : err instanceof Error
+        ? err.message
+        : "Failed to fetch feed";
+    await prisma.calendarFeed.update({
+      where: { id: feedId },
+      data: { lastError: message.slice(0, 200) },
+    });
+    return { ok: false, error: message };
+  }
+
+  const ical: typeof icalNS = await import("node-ical");
+
+  let parsed: icalNS.CalendarResponse;
+  try {
+    parsed = ical.sync.parseICS(text);
+  } catch {
+    await prisma.calendarFeed.update({
+      where: { id: feedId },
+      data: { lastError: "Could not parse calendar data" },
+    });
+    return { ok: false, error: "Could not parse calendar data" };
+  }
+
+  const now = new Date();
+  const windowStart = new Date(now.getTime() - CALENDAR_FEED_PAST_DAYS * 86_400_000);
+  const windowEnd = new Date(now.getTime() + CALENDAR_FEED_FUTURE_DAYS * 86_400_000);
+
+  const rows: EventRow[] = [];
+  const seenUids = new Set<string>();
+
+  // Pre-pass: collect all overridden occurrence start times by master event uid
+  const overridesByUid = new Map<string, Set<number>>();
+  for (const item of Object.values(parsed)) {
+    if (!item || typeof item !== "object" || (item as { type?: string }).type !== "VEVENT") continue;
+    const event = item as icalNS.VEvent;
+    if (event.uid && event.recurrenceid) {
+      const recIdDate = event.recurrenceid instanceof Date ? event.recurrenceid : new Date(event.recurrenceid);
+      if (!Number.isNaN(recIdDate.getTime())) {
+        if (!overridesByUid.has(event.uid)) {
+          overridesByUid.set(event.uid, new Set());
+        }
+        overridesByUid.get(event.uid)!.add(recIdDate.getTime());
+      }
+    }
+  }
+
+  for (const item of Object.values(parsed)) {
+    if (!item || typeof item !== "object" || (item as { type?: string }).type !== "VEVENT") continue;
+    const event = item as icalNS.VEvent;
+
+    if (event.rrule) {
+      const instances = ical.expandRecurringEvent(event, { from: windowStart, to: windowEnd });
+      for (const inst of instances) {
+        // Skip if this instance's start matches an overridden occurrence
+        if (event.uid && overridesByUid.get(event.uid)?.has(inst.start.getTime())) {
+          continue;
+        }
+        // Skip if this instance's start is excluded via EXDATE
+        if (isDateExcluded(event.exdate, inst.start)) {
+          continue;
+        }
+
+        const uid = `${event.uid}-${inst.start.toISOString()}`;
+        if (seenUids.has(uid)) continue;
+        seenUids.add(uid);
+
+        let end = inst.end;
+        if (inst.isFullDay && end > inst.start) {
+          end = new Date(end.getTime() - 86_400_000);
+        }
+
+        rows.push({
+          uid,
+          title: summaryText(inst.summary),
+          start: inst.start,
+          end,
+          allDay: inst.isFullDay,
+        });
+      }
+      continue;
+    }
+
+    const start = event.start;
+    let end = event.end ?? event.start;
+    if (!start) continue;
+    if (end < windowStart || start > windowEnd) continue;
+
+    // Use suffix for overrides to prevent duplicate key constraint
+    const recIdDate = event.recurrenceid
+      ? event.recurrenceid instanceof Date
+        ? event.recurrenceid
+        : new Date(event.recurrenceid)
+      : null;
+    const uid = recIdDate ? `${event.uid}-${recIdDate.toISOString()}` : event.uid;
+
+    if (seenUids.has(uid)) continue;
+    seenUids.add(uid);
+
+    const allDay = event.datetype === "date";
+    if (allDay && end > start) {
+      end = new Date(end.getTime() - 86_400_000);
+    }
+
+    rows.push({ uid, title: summaryText(event.summary), start, end, allDay });
+  }
+
+  await prisma.$transaction(async (tx) => {
+    await tx.calendarFeedEvent.deleteMany({ where: { feedId } });
+    if (rows.length > 0) {
+      await tx.calendarFeedEvent.createMany({
+        data: rows.map((r) => ({
+          feedId,
+          uid: r.uid,
+          title: r.title,
+          start: r.start,
+          end: r.end,
+          allDay: r.allDay,
+        })),
+      });
+    }
+    await tx.calendarFeed.update({
+      where: { id: feedId },
+      data: { lastFetchedAt: new Date(), lastError: null },
+    });
+  });
+
+  return { ok: true };
+}
+
+/** Fetch the .ics body with a timeout and a hard size cap (Content-Length + streamed). */
+async function fetchIcsBody(url: string): Promise<string> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), ICS_FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers: { Accept: "text/calendar, */*" },
+    });
+    if (!res.ok) throw new Error(`Upstream returned ${res.status}`);
+
+    const contentLength = res.headers.get("content-length");
+    if (contentLength && Number(contentLength) > ICS_MAX_BYTES) {
+      throw new Error("Feed is too large");
+    }
+
+    const reader = res.body?.getReader();
+    if (!reader) {
+      const body = await res.text();
+      if (Buffer.byteLength(body, "utf8") > ICS_MAX_BYTES) throw new Error("Feed is too large");
+      return body;
+    }
+
+    const chunks: Buffer[] = [];
+    let total = 0;
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) {
+        total += value.byteLength;
+        if (total > ICS_MAX_BYTES) {
+          await reader.cancel();
+          throw new Error("Feed is too large");
+        }
+        chunks.push(Buffer.from(value));
+      }
+    }
+    return Buffer.concat(chunks).toString("utf8");
+  } finally {
+    clearTimeout(timeout);
+  }
+}

package/lib/client/online-status.ts

@@ -0,0 +1,47 @@
+"use client";
+
+import { useEffect, useState } from "react";
+
+// Reachability probe: navigator.onLine only tells us the device has *a* network,
+// not that our server is reachable. /api/health is a tiny always-200 endpoint we
+// can ping to confirm the app is actually reachable.
+export async function probeReachable(timeoutMs = 4000): Promise<boolean> {
+  if (typeof navigator !== "undefined" && navigator.onLine === false) return false;
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), timeoutMs);
+    const res = await fetch("/api/health", { cache: "no-store", signal: ctrl.signal });
+    clearTimeout(t);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+// Subscribe to online/offline transitions. `onChange` is called with the new
+// state. Uses the browser events for instant feedback (navigator.onLine).
+export function useOnlineStatus(onChange?: (online: boolean) => void): boolean {
+  const [online, setOnline] = useState(
+    typeof navigator === "undefined" ? true : navigator.onLine
+  );
+
+  useEffect(() => {
+    function update(next: boolean) {
+      setOnline(next);
+      onChange?.(next);
+    }
+    const goOnline = () => update(true);
+    const goOffline = () => update(false);
+    window.addEventListener("online", goOnline);
+    window.addEventListener("offline", goOffline);
+    return () => {
+      window.removeEventListener("online", goOnline);
+      window.removeEventListener("offline", goOffline);
+    };
+    // onChange intentionally excluded — callers pass a stable callback or accept
+    // the latest closure is captured on mount; status value still updates via state.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  return online;
+}

package/lib/conflict-resolver.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { threeWayMerge, lastWriteWins } from "@/lib/conflict-resolver";
+
+const P = (...ps: string[]) => ps.join("\n\n");
+
+describe("threeWayMerge", () => {
+  it("returns either side when they are equal", () => {
+    const r = threeWayMerge("base", "same", "same");
+    expect(r.merged).toBe("same");
+    expect(r.hasConflicts).toBe(false);
+  });
+
+  it("takes the changed side when the other is unchanged", () => {
+    expect(threeWayMerge("a", "a", "b").merged).toBe("b");
+    expect(threeWayMerge("a", "b", "a").merged).toBe("b");
+  });
+
+  it("unions non-overlapping additions from both sides", () => {
+    const base = P("intro");
+    const local = P("intro", "local note");
+    const cloud = P("intro", "cloud note");
+    const r = threeWayMerge(base, local, cloud);
+    expect(r.hasConflicts).toBe(false);
+    expect(r.merged).toContain("local note");
+    expect(r.merged).toContain("cloud note");
+  });
+
+  it("preserves legitimately duplicated paragraphs (no global de-dup)", () => {
+    const dup = P("repeat", "repeat", "tail");
+    const r = threeWayMerge("repeat", dup, dup);
+    expect(r.merged).toBe(dup);
+  });
+
+  it("flags competing edits in the same region as a conflict", () => {
+    const base = P("anchor", "original", "end");
+    const local = P("anchor", "local edit", "end");
+    const cloud = P("anchor", "cloud edit", "end");
+    const r = threeWayMerge(base, local, cloud);
+    expect(r.hasConflicts).toBe(true);
+    expect(r.conflicts[0]).toEqual({ localVersion: "local edit", cloudVersion: "cloud edit" });
+  });
+});
+
+describe("lastWriteWins", () => {
+  it("prefers the newer timestamp", () => {
+    const older = { id: "a", updatedAt: new Date(1000), version: 5 };
+    const newer = { id: "a", updatedAt: new Date(2000), version: 1 };
+    expect(lastWriteWins(newer, older)).toBe("local");
+    expect(lastWriteWins(older, newer)).toBe("cloud");
+  });
+
+  it("breaks ties by version", () => {
+    const local = { id: "a", updatedAt: new Date(1000), version: 3 };
+    const cloud = { id: "a", updatedAt: new Date(1000), version: 2 };
+    expect(lastWriteWins(local, cloud)).toBe("local");
+  });
+});

package/lib/conflict-resolver.ts

@@ -0,0 +1,240 @@
+import { prisma, getCloudPrisma } from "@/lib/prisma";
+import type { PrismaClient } from "@/app/generated/prisma/client";
+
+// --- Types ---
+
+export type MergeResult = {
+  merged: string;
+  hasConflicts: boolean;
+  conflicts: Array<{ localVersion: string; cloudVersion: string }>;
+};
+
+export type TaskSyncable = {
+  id: string;
+  updatedAt: Date;
+  version: number;
+};
+
+// --- Last Write Wins ---
+
+export function lastWriteWins(
+  local: TaskSyncable,
+  cloud: TaskSyncable
+): "local" | "cloud" {
+  if (local.updatedAt > cloud.updatedAt) return "local";
+  if (cloud.updatedAt > local.updatedAt) return "cloud";
+  return local.version >= cloud.version ? "local" : "cloud";
+}
+
+// --- Union Merge for task ID sets ---
+
+export function unionMergeIds(
+  localIds: Set<string>,
+  cloudIds: Set<string>
+): { onlyLocal: string[]; onlyCloud: string[] } {
+  const onlyLocal = [...localIds].filter((id) => !cloudIds.has(id));
+  const onlyCloud = [...cloudIds].filter((id) => !localIds.has(id));
+  return { onlyLocal, onlyCloud };
+}
+
+// --- Paragraph-level three-way merge ---
+
+function splitParagraphs(text: string): string[] {
+  return text.split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
+}
+
+// Longest Common Subsequence of paragraph arrays
+function lcs(a: string[], b: string[]): string[] {
+  const m = a.length;
+  const n = b.length;
+
+  // Bail on very large inputs to avoid O(mn) blowup
+  if (m * n > 40000) return [];
+
+  const dp: number[][] = Array.from({ length: m + 1 }, () =>
+    new Array(n + 1).fill(0)
+  );
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] =
+        a[i - 1] === b[j - 1]
+          ? dp[i - 1][j - 1] + 1
+          : Math.max(dp[i - 1][j], dp[i][j - 1]);
+    }
+  }
+
+  const result: string[] = [];
+  let i = m, j = n;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      result.unshift(a[i - 1]);
+      i--;
+      j--;
+    } else if (dp[i - 1][j] >= dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+  return result;
+}
+
+/**
+ * Three-way merge at the paragraph level.
+ *
+ * base  = last synced content (stored snapshot)
+ * local = current local content
+ * cloud = current cloud content
+ *
+ * Strategy: anchor on the longest common subsequence of local↔cloud paragraphs.
+ * Between consecutive anchors, each side may contribute a "run" of paragraphs:
+ *   - one side empty            → take the other side's run (an add/keep)
+ *   - both runs identical       → take it once (same edit on both sides)
+ *   - both runs differ          → genuine conflict in that region (flag it,
+ *                                 and keep the local run in the provisional
+ *                                 merge, which is only used when nothing conflicts)
+ * Anchors are consumed in order, so legitimately repeated paragraphs are
+ * preserved (no global de-duplication). Union bias is intentional for PM notes:
+ * when in doubt we keep content rather than drop it.
+ *
+ * `base` is used for the equality fast-paths; the merge itself is local↔cloud.
+ */
+export function threeWayMerge(
+  base: string,
+  local: string,
+  cloud: string
+): MergeResult {
+  // Fast paths
+  if (local === cloud) return { merged: local, hasConflicts: false, conflicts: [] };
+  if (local === base) return { merged: cloud, hasConflicts: false, conflicts: [] };
+  if (cloud === base) return { merged: local, hasConflicts: false, conflicts: [] };
+
+  const B = splitParagraphs(base);
+  const L = splitParagraphs(local);
+  const C = splitParagraphs(cloud);
+  const anchors = lcs(L, C); // shared paragraphs, in order
+
+  const conflicts: Array<{ localVersion: string; cloudVersion: string }> = [];
+  const result: string[] = [];
+
+  // baseRun = what base held in this region. Empty base region + differing runs
+  // means both sides *added* here (auto-mergeable union); a non-empty base region
+  // that both sides changed differently is a genuine conflict.
+  const flushGap = (localRun: string[], cloudRun: string[], baseRun: string[]) => {
+    if (cloudRun.length === 0) { result.push(...localRun); return; }
+    if (localRun.length === 0) { result.push(...cloudRun); return; }
+    if (
+      localRun.length === cloudRun.length &&
+      localRun.every((p, k) => p === cloudRun[k])
+    ) {
+      result.push(...localRun); // both sides made the same edit
+      return;
+    }
+    if (baseRun.length === 0) {
+      result.push(...localRun, ...cloudRun); // independent additions → union
+      return;
+    }
+    conflicts.push({
+      localVersion: localRun.join("\n\n"),
+      cloudVersion: cloudRun.join("\n\n"),
+    });
+    result.push(...localRun);
+  };
+
+  let li = 0;
+  let ci = 0;
+  let bi = 0;
+  for (const anchor of anchors) {
+    const lNext = L.indexOf(anchor, li);
+    const cNext = C.indexOf(anchor, ci);
+    const bNext = B.indexOf(anchor, bi); // -1 if both sides added this anchor
+    flushGap(L.slice(li, lNext), C.slice(ci, cNext), bNext === -1 ? [] : B.slice(bi, bNext));
+    result.push(anchor);
+    li = lNext + 1;
+    ci = cNext + 1;
+    if (bNext !== -1) bi = bNext + 1;
+  }
+  // Trailing run after the last anchor.
+  flushGap(L.slice(li), C.slice(ci), B.slice(bi));
+
+  return {
+    merged: result.join("\n\n"),
+    hasConflicts: conflicts.length > 0,
+    conflicts,
+  };
+}
+
+// --- Tombstone helpers ---
+
+export async function isTombstoned(
+  workspaceId: string,
+  entityType: string,
+  entityId: string,
+  db: PrismaClient = prisma
+): Promise<boolean> {
+  const record = await db.tombstone.findFirst({
+    where: { workspaceId, entityType, entityId },
+  });
+  return record !== null;
+}
+
+export async function writeTombstone(
+  workspaceId: string,
+  entityType: string,
+  entityId: string
+): Promise<void> {
+  const where = { workspaceId, entityType, entityId };
+
+  // Write to local PGlite
+  const existing = await prisma.tombstone.findFirst({ where });
+  if (!existing) {
+    await prisma.tombstone.create({ data: where });
+  }
+
+  // Mirror to Neon so syncing devices don't resurrect deleted records
+  const cloud = getCloudPrisma();
+  if (cloud) {
+    const cloudExisting = await cloud.tombstone.findFirst({ where });
+    if (!cloudExisting) {
+      await cloud.tombstone.create({ data: where });
+    }
+  }
+}
+
+// --- Conflict log helpers ---
+
+export async function logConflict(
+  workspaceId: string,
+  entityType: "note" | "task",
+  entityId: string,
+  localValue: string,
+  cloudValue: string,
+  db: PrismaClient = prisma
+): Promise<string> {
+  // Use upsert so a second conflict on the same entity (before the first is
+  // resolved) refreshes the values instead of throwing a unique-constraint error
+  // and silently killing the entire sync flush for this workspace.
+  const record = await db.conflictLog.upsert({
+    where: { workspaceId_entityType_entityId: { workspaceId, entityType, entityId } },
+    create: { workspaceId, entityType, entityId, localValue, cloudValue },
+    update: {
+      // Keep the original localValue as the baseline; update cloudValue with
+      // the latest cloud state so the user always sees the most recent divergence.
+      cloudValue,
+      resolvedBy: null,
+      resolvedAt: null,
+    },
+  });
+  return record.id;
+}
+
+export async function resolveConflict(
+  conflictId: string,
+  resolvedBy: "local" | "cloud" | "user",
+  db: PrismaClient = prisma
+): Promise<void> {
+  await db.conflictLog.update({
+    where: { id: conflictId },
+    data: { resolvedBy, resolvedAt: new Date() },
+  });
+}

package/lib/db-init.ts

@@ -0,0 +1,79 @@
+/**
+ * PGlite startup migration runner.
+ *
+ * On every app start, reads the SQL files from prisma/migrations/ and applies
+ * any that haven't been applied to the local PGlite database yet.
+ *
+ * This replaces `prisma migrate deploy` for the local embedded DB — the
+ * migration files are generated by `prisma migrate dev` (against Neon) and
+ * bundled with the package, so local users get schema updates automatically
+ * on the next `npx @brief/app` run.
+ */
+
+import { type PGlite } from "@electric-sql/pglite";
+import fs from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+
+const MIGRATIONS_TABLE = `
+  CREATE TABLE IF NOT EXISTS "_prisma_migrations" (
+    "id"                  VARCHAR(36)  NOT NULL PRIMARY KEY,
+    "checksum"            VARCHAR(64)  NOT NULL,
+    "finished_at"         TIMESTAMPTZ,
+    "migration_name"      VARCHAR(255) NOT NULL,
+    "logs"                TEXT,
+    "rolled_back_at"      TIMESTAMPTZ,
+    "started_at"          TIMESTAMPTZ  NOT NULL DEFAULT now(),
+    "applied_steps_count" INTEGER      NOT NULL DEFAULT 0
+  );
+`;
+
+export async function runLocalMigrations(db: PGlite): Promise<void> {
+  // Ensure tracking table exists
+  await db.exec(MIGRATIONS_TABLE);
+
+  const migrationsDir = path.join(process.cwd(), "prisma", "migrations");
+
+  if (!fs.existsSync(migrationsDir)) {
+    console.warn(
+      "[Brief] No migration files found. Run `prisma migrate dev --name init` to generate them."
+    );
+    return;
+  }
+
+  // Get already-applied migrations
+  const result = await db.query<{ migration_name: string }>(
+    `SELECT migration_name FROM "_prisma_migrations" WHERE finished_at IS NOT NULL ORDER BY started_at`
+  );
+  const applied = new Set(result.rows.map((r) => r.migration_name));
+
+  // Read migration directories sorted by name (timestamp prefix ensures order)
+  const dirs = fs
+    .readdirSync(migrationsDir)
+    .filter((d) => fs.statSync(path.join(migrationsDir, d)).isDirectory())
+    .sort();
+
+  for (const dir of dirs) {
+    if (applied.has(dir)) continue;
+
+    const sqlFile = path.join(migrationsDir, dir, "migration.sql");
+    if (!fs.existsSync(sqlFile)) continue;
+
+    const sql = fs.readFileSync(sqlFile, "utf-8");
+    const id = randomUUID();
+
+    try {
+      await db.exec(sql);
+      await db.query(
+        `INSERT INTO "_prisma_migrations"
+           (id, checksum, finished_at, migration_name, applied_steps_count)
+         VALUES ($1, '', now(), $2, 1)`,
+        [id, dir]
+      );
+      console.log(`[Brief] Applied migration: ${dir}`);
+    } catch (err) {
+      console.error(`[Brief] Migration failed: ${dir}`, err);
+      throw err;
+    }
+  }
+}