@knotpad/app 0.1.0 → 0.1.2

package/lib/backup/export-workspace-backup.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  cleanBackupContent,
-  getBackupFilename,
-} from "@/lib/backup/export-workspace-backup";
-
-describe("workspace backup export", () => {
-  it("removes internal task comments from exported note content", () => {
-    const input = "Hello<!--task::OPEN-->\nWorld";
-    expect(cleanBackupContent(input)).toBe("Hello\nWorld");
-  });
-
-  it("builds a timestamped backup filename", () => {
-    const filename = getBackupFilename(new Date("2026-06-13T09:15:00.000Z"));
-    expect(filename).toBe("brief-backup-2026-06-13.json");
-  });
-});

package/lib/backup/export-workspace-backup.ts

@@ -1,77 +0,0 @@
-import { prisma } from "@/lib/prisma";
-import { decryptContent } from "@/lib/note-crypto";
-
-const BADGE_COMMENT_RE = /\s*<!--task::[^>]*-->/g;
-
-export function cleanBackupContent(content: string): string {
-  return content
-    .split("\n")
-    .map((line) => line.replace(BADGE_COMMENT_RE, ""))
-    .join("\n");
-}
-
-export function getBackupFilename(now = new Date()): string {
-  return `brief-backup-${now.toISOString().split("T")[0]}.json`;
-}
-
-export async function buildWorkspaceBackup(
-  workspaceId: string,
-  workspaceName: string,
-  workspaceSlug: string
-) {
-  const notes = await prisma.note.findMany({
-    where: { workspaceId },
-    orderBy: { createdAt: "asc" },
-    include: {
-      tasks: {
-        orderBy: { createdAt: "asc" },
-        select: {
-          id: true,
-          title: true,
-          status: true,
-          assigneeType: true,
-          fileRefs: true,
-          dueDate: true,
-          createdAt: true,
-          updatedAt: true,
-        },
-      },
-    },
-  });
-
-  const decryptedNotes = await Promise.all(
-    notes.map(async (note) => ({
-      ...note,
-      content: cleanBackupContent(await decryptContent(note.content, workspaceId)),
-    }))
-  );
-
-  return {
-    filename: getBackupFilename(),
-    payload: {
-      version: 1,
-      exportedAt: new Date().toISOString(),
-      workspace: {
-        name: workspaceName,
-        slug: workspaceSlug,
-      },
-      notes: decryptedNotes.map((note) => ({
-        id: note.id,
-        title: note.title,
-        content: note.content,
-        createdAt: note.createdAt.toISOString(),
-        updatedAt: note.updatedAt.toISOString(),
-        tasks: note.tasks.map((task) => ({
-          id: task.id,
-          title: task.title,
-          status: task.status,
-          assigneeType: task.assigneeType,
-          fileRefs: task.fileRefs,
-          dueDate: task.dueDate?.toISOString() ?? null,
-          createdAt: task.createdAt.toISOString(),
-          updatedAt: task.updatedAt.toISOString(),
-        })),
-      })),
-    },
-  };
-}

package/lib/backup/restore-workspace-from-export.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { planRestoreChanges } from "@/lib/backup/restore-workspace-from-export";
-
-describe("planRestoreChanges", () => {
-  it("tombstones records missing from the imported backup and clears tombstones for restored ids", () => {
-    const plan = planRestoreChanges({
-      existingNoteIds: ["old_note", "keep_note"],
-      existingTaskIds: ["old_task", "keep_task"],
-      importedNoteIds: ["keep_note", "new_note"],
-      importedTaskIds: ["keep_task", "new_task"],
-    });
-
-    expect(plan.noteIdsToTombstone).toEqual(["old_note"]);
-    expect(plan.taskIdsToTombstone).toEqual(["old_task"]);
-    expect(plan.noteIdsToClearTombstones).toEqual(["keep_note", "new_note"]);
-    expect(plan.taskIdsToClearTombstones).toEqual(["keep_task", "new_task"]);
-  });
-});

package/lib/backup/restore-workspace-from-export.ts

@@ -1,183 +0,0 @@
-import { getCloudPrisma, prisma } from "@/lib/prisma";
-import { writeTombstone } from "@/lib/conflict-resolver";
-import { saveSnapshots } from "@/lib/note-sync";
-
-export type BriefExport = {
-  version: number;
-  exportedAt: string;
-  workspace: { name: string; slug: string };
-  notes: Array<{
-    id: string;
-    title: string;
-    content: string;
-    createdAt: string;
-    updatedAt: string;
-    tasks: Array<{
-      id: string;
-      title: string;
-      status: string;
-      assigneeType: string;
-      fileRefs: string[];
-      dueDate: string | null;
-      createdAt: string;
-      updatedAt: string;
-    }>;
-  }>;
-};
-
-export function planRestoreChanges(input: {
-  existingNoteIds: string[];
-  existingTaskIds: string[];
-  importedNoteIds: string[];
-  importedTaskIds: string[];
-}) {
-  const importedNotes = new Set(input.importedNoteIds);
-  const importedTasks = new Set(input.importedTaskIds);
-
-  return {
-    noteIdsToTombstone: input.existingNoteIds.filter((id) => !importedNotes.has(id)),
-    taskIdsToTombstone: input.existingTaskIds.filter((id) => !importedTasks.has(id)),
-    noteIdsToClearTombstones: input.importedNoteIds,
-    taskIdsToClearTombstones: input.importedTaskIds,
-  };
-}
-
-export async function restoreWorkspaceFromExport(params: {
-  workspaceId: string;
-  exportData: BriefExport;
-  pushToCloud: boolean;
-}) {
-  const cloudPrisma = getCloudPrisma();
-  if (params.pushToCloud && !cloudPrisma) {
-    throw new Error("Cloud restore is not configured for this workspace.");
-  }
-
-  const [existingNotes, existingTasks] = await Promise.all([
-    prisma.note.findMany({
-      where: { workspaceId: params.workspaceId },
-      select: { id: true },
-    }),
-    prisma.task.findMany({
-      where: { workspaceId: params.workspaceId },
-      select: { id: true },
-    }),
-  ]);
-
-  const importedNoteIds = params.exportData.notes.map((note) => note.id);
-  const importedTaskIds = params.exportData.notes.flatMap((note) =>
-    note.tasks.map((task) => task.id)
-  );
-
-  const plan = planRestoreChanges({
-    existingNoteIds: existingNotes.map((note) => note.id),
-    existingTaskIds: existingTasks.map((task) => task.id),
-    importedNoteIds,
-    importedTaskIds,
-  });
-
-  await Promise.all([
-    ...plan.noteIdsToTombstone.map((id) =>
-      writeTombstone(params.workspaceId, "note", id)
-    ),
-    ...plan.taskIdsToTombstone.map((id) =>
-      writeTombstone(params.workspaceId, "task", id)
-    ),
-  ]);
-
-  const noteRows = params.exportData.notes.map((note) => ({
-    id: note.id,
-    title: note.title,
-    content: note.content,
-    workspaceId: params.workspaceId,
-    pendingSync: false,
-    createdAt: new Date(note.createdAt),
-    updatedAt: new Date(note.updatedAt),
-  }));
-
-  const taskRows = params.exportData.notes.flatMap((note) =>
-    note.tasks.map((task) => ({
-      id: task.id,
-      title: task.title,
-      status: task.status as never,
-      noteId: note.id,
-      workspaceId: params.workspaceId,
-      assigneeType: task.assigneeType as never,
-      fileRefs: task.fileRefs,
-      dueDate: task.dueDate ? new Date(task.dueDate) : null,
-      pendingSync: false,
-      createdAt: new Date(task.createdAt),
-      updatedAt: new Date(task.updatedAt),
-    }))
-  );
-
-  const importedEntityIds = [
-    ...plan.noteIdsToClearTombstones,
-    ...plan.taskIdsToClearTombstones,
-  ];
-
-  const restoreLocal = prisma.$transaction(async (tx) => {
-    await tx.task.deleteMany({ where: { workspaceId: params.workspaceId } });
-    await tx.note.deleteMany({ where: { workspaceId: params.workspaceId } });
-    await tx.conflictLog.deleteMany({ where: { workspaceId: params.workspaceId } });
-    await tx.tombstone.deleteMany({
-      where: {
-        workspaceId: params.workspaceId,
-        entityId: { in: importedEntityIds },
-      },
-    });
-
-    if (noteRows.length > 0) {
-      await tx.note.createMany({ data: noteRows });
-    }
-
-    if (taskRows.length > 0) {
-      await tx.task.createMany({ data: taskRows });
-    }
-
-    await tx.syncState.upsert({
-      where: { workspaceId: params.workspaceId },
-      update: { lastSyncedAt: new Date() },
-      create: { workspaceId: params.workspaceId, lastSyncedAt: new Date() },
-    });
-  });
-
-  const restoreCloud =
-    params.pushToCloud && cloudPrisma
-      ? cloudPrisma.$transaction(async (tx) => {
-          await tx.task.deleteMany({ where: { workspaceId: params.workspaceId } });
-          await tx.note.deleteMany({ where: { workspaceId: params.workspaceId } });
-          await tx.conflictLog.deleteMany({ where: { workspaceId: params.workspaceId } });
-          await tx.tombstone.deleteMany({
-            where: {
-              workspaceId: params.workspaceId,
-              entityId: { in: importedEntityIds },
-            },
-          });
-
-          if (noteRows.length > 0) {
-            await tx.note.createMany({ data: noteRows });
-          }
-
-          if (taskRows.length > 0) {
-            await tx.task.createMany({ data: taskRows });
-          }
-
-          await tx.syncState.upsert({
-            where: { workspaceId: params.workspaceId },
-            update: { lastSyncedAt: new Date() },
-            create: { workspaceId: params.workspaceId, lastSyncedAt: new Date() },
-          });
-        })
-      : Promise.resolve();
-
-  await Promise.all([restoreLocal, restoreCloud]);
-
-  const snapshots = Object.fromEntries(
-    params.exportData.notes.map((note) => [note.id, note.content])
-  );
-
-  await saveSnapshots(params.workspaceId, snapshots, undefined, prisma);
-  if (params.pushToCloud && cloudPrisma) {
-    await saveSnapshots(params.workspaceId, snapshots, undefined, cloudPrisma);
-  }
-}

package/lib/backup/types.ts

@@ -1,14 +0,0 @@
-export type BackupCadence = "DAILY" | "WEEKLY" | "MONTHLY";
-
-export type BackupRunStatus = "idle" | "success" | "error" | "running";
-
-export type BackupSettingsRecord = {
-  workspaceId: string;
-  scheduleEnabled: boolean;
-  scheduleCadence: BackupCadence;
-  destinationPath: string | null;
-  includeMarkdownZip: boolean;
-  lastBackupAt: Date | null;
-  lastBackupStatus: BackupRunStatus;
-  lastBackupError: string | null;
-};

package/lib/brand-icons.ts

@@ -1 +0,0 @@
-export const WEB_ICON_PATH = "/icon_dark.svg";

package/lib/calendar-feed-crypto.ts

@@ -1,38 +0,0 @@
-/**
- * Encryption-at-rest for CalendarFeed subscription URLs.
- *
- * The .ics URL is effectively a credential — anyone with it can read the
- * user's calendar — so it's encrypted with the same AES-256-GCM scheme as
- * note content (lib/encryption.ts), but with a per-row salt stored on the
- * CalendarFeed itself (CalendarFeed.urlSalt) rather than a per-workspace salt.
- *
- * In local-only mode (no cloud sync), URLs are stored as plaintext since
- * the data never leaves the user's device.
- */
-
-import { encryptNote, decryptNote, isEncrypted } from "@/lib/encryption";
-
-function isCloudEnabled(): boolean {
-  return process.env.IS_CLOUD === "true" || !!process.env.CLOUD_DATABASE_URL;
-}
-
-function getPepper(): string {
-  const pepper = process.env.ENCRYPTION_PEPPER;
-  if (!pepper) {
-    throw new Error(
-      "[Brief] ENCRYPTION_PEPPER env var is required to encrypt calendar feed URLs at rest. " +
-      "Generate one with: openssl rand -base64 32"
-    );
-  }
-  return pepper;
-}
-
-export async function encryptFeedUrl(url: string, salt: string): Promise<string> {
-  if (!isCloudEnabled()) return url; // local-only: store plaintext
-  return encryptNote(url, getPepper(), salt);
-}
-
-export async function decryptFeedUrl(encrypted: string, salt: string): Promise<string> {
-  if (!isEncrypted(encrypted)) return encrypted; // plaintext / local-only safety
-  return decryptNote(encrypted, getPepper(), salt);
-}

package/lib/calendar-feed.ts

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

@@ -1,47 +0,0 @@
-"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;
-}