@knotpad/app 0.1.4 → 0.1.6

package/lib/backup/backup-settings.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { validateBackupSettingsInput } from "@/lib/backup/backup-settings";
+
+describe("validateBackupSettingsInput", () => {
+  it("rejects scheduled backups without a destination path", () => {
+    const result = validateBackupSettingsInput({
+      scheduleEnabled: true,
+      scheduleCadence: "WEEKLY",
+      destinationPath: "",
+      includeMarkdownZip: false,
+      isCloudWorkspace: false,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("Choose a destination folder before enabling scheduled backup.");
+  });
+
+  it("rejects scheduled backup for cloud workspaces", () => {
+    const result = validateBackupSettingsInput({
+      scheduleEnabled: true,
+      scheduleCadence: "DAILY",
+      destinationPath: "C:/Backups",
+      includeMarkdownZip: true,
+      isCloudWorkspace: true,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("Scheduled local backup is not available for cloud workspaces.");
+  });
+});

package/lib/backup/backup-settings.ts

@@ -0,0 +1,27 @@
+import type { BackupCadence } from "@/lib/backup/types";
+
+type BackupSettingsInput = {
+  scheduleEnabled: boolean;
+  scheduleCadence: BackupCadence;
+  destinationPath: string;
+  includeMarkdownZip: boolean;
+  isCloudWorkspace: boolean;
+};
+
+export function validateBackupSettingsInput(input: BackupSettingsInput) {
+  if (input.scheduleEnabled && input.isCloudWorkspace) {
+    return {
+      success: false as const,
+      error: "Scheduled local backup is not available for cloud workspaces.",
+    };
+  }
+
+  if (input.scheduleEnabled && !input.destinationPath.trim()) {
+    return {
+      success: false as const,
+      error: "Choose a destination folder before enabling scheduled backup.",
+    };
+  }
+
+  return { success: true as const };
+}

package/lib/backup/export-notes-zip.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import {
+  listZipEntries,
+  slugifyNoteFilename,
+  toMarkdownDocument,
+} from "@/lib/backup/export-notes-zip";
+
+describe("notes zip export", () => {
+  it("wraps note title and content into markdown", () => {
+    expect(toMarkdownDocument("Roadmap", "Line 1")).toBe("# Roadmap\n\nLine 1");
+  });
+
+  it("keeps duplicate note filenames unique", () => {
+    const entries = listZipEntries([
+      { id: "note_a", title: "Plan", content: "A", folderName: null },
+      { id: "note_b", title: "Plan", content: "B", folderName: null },
+    ]);
+
+    expect(entries[0].path).toBe("plan.md");
+    expect(entries[1].path).toBe("plan-note_b.md");
+  });
+
+  it("slugifies note filenames safely", () => {
+    expect(slugifyNoteFilename("Q3 / Goals")).toBe("q3-goals");
+  });
+});

package/lib/backup/export-notes-zip.ts

@@ -0,0 +1,82 @@
+import { strToU8, zipSync } from "fflate";
+import { prisma } from "@/lib/prisma";
+import { decryptContent } from "@/lib/note-crypto";
+import { cleanBackupContent } from "@/lib/backup/export-workspace-backup";
+
+type NotesZipEntry = {
+  path: string;
+  content: string;
+};
+
+type NotesZipSource = {
+  id: string;
+  title: string;
+  content: string;
+  folderName: string | null;
+};
+
+export function slugifyNoteFilename(title: string): string {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "note";
+}
+
+export function toMarkdownDocument(title: string, content: string): string {
+  return `# ${title}\n\n${content}`;
+}
+
+export function listZipEntries(notes: NotesZipSource[]): NotesZipEntry[] {
+  const seen = new Set<string>();
+
+  return notes.map((note) => {
+    const baseName = slugifyNoteFilename(note.title);
+    const folderPrefix = note.folderName ? `${slugifyNoteFilename(note.folderName)}/` : "";
+    const defaultPath = `${folderPrefix}${baseName}.md`;
+    const path = seen.has(defaultPath)
+      ? `${folderPrefix}${baseName}-${note.id}.md`
+      : defaultPath;
+
+    seen.add(path);
+
+    return {
+      path,
+      content: toMarkdownDocument(note.title, note.content),
+    };
+  });
+}
+
+export function buildNotesZip(entries: NotesZipEntry[]): Uint8Array {
+  const archive = Object.fromEntries(
+    entries.map((entry) => [entry.path, strToU8(entry.content)])
+  );
+
+  return zipSync(archive, { level: 6 });
+}
+
+export async function buildNotesZipExport(workspaceId: string) {
+  const notes = await prisma.note.findMany({
+    where: { workspaceId },
+    orderBy: { createdAt: "asc" },
+    include: {
+      folder: {
+        select: {
+          name: true,
+        },
+      },
+    },
+  });
+
+  const entries = listZipEntries(
+    await Promise.all(
+      notes.map(async (note) => ({
+        id: note.id,
+        title: note.title,
+        content: cleanBackupContent(await decryptContent(note.content, workspaceId)),
+        folderName: note.folder?.name ?? null,
+      }))
+    )
+  );
+
+  return {
+    filename: `brief-notes-${new Date().toISOString().split("T")[0]}.zip`,
+    bytes: buildNotesZip(entries),
+  };
+}

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

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

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

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

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

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

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

package/lib/calendar-feed-crypto.ts

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