@knotpad/app 0.1.4 → 0.1.6

package/lib/sync-worker.ts

@@ -0,0 +1,388 @@
+/**
+ * Cloud sync worker — server-side only.
+ *
+ * Runs every 5 minutes via cron (or on demand via POST /api/sync/trigger).
+ * Pulls cloud changes, pulls local changes, resolves conflicts, pushes back.
+ *
+ * Strategy per entity type:
+ *  - Task status/assignment → last-write-wins (timestamp)
+ *  - New tasks on both sides → union merge (keep all)
+ *  - Note content → three-way merge (paragraph level, stored base snapshot)
+ *  - Deletes → tombstone pattern (check before insert, write on delete)
+ */
+
+import { prisma, getCloudPrisma } from "@/lib/prisma";
+import {
+  lastWriteWins,
+  threeWayMerge,
+  isTombstoned,
+  logConflict,
+} from "@/lib/conflict-resolver";
+import {
+  getOrCreateSyncState,
+  getSnapshots,
+  saveSnapshots,
+  saveSnapshot,
+} from "@/lib/note-sync";
+import { encryptForSync, decryptFromSync } from "@/lib/note-crypto";
+import { isWorkspacePro, isWorkspaceCloud } from "@/lib/license";
+
+// In-process guard so the cron run and an on-demand /api/sync/trigger can't
+// process the same workspace concurrently (which would race cloud writes and
+// throw on duplicate-id inserts). Per-instance; a DB-backed lock would be
+// needed for multi-instance deployments.
+const inFlight = new Set<string>();
+
+export type SyncStatus =
+  | "synced"
+  | "syncing"
+  | "conflict"
+  | "offline"
+  | "lapsed"
+  | "error";
+
+export type SyncResult = {
+  status: SyncStatus;
+  notesProcessed: number;
+  tasksProcessed: number;
+  conflictsFound: number;
+  error?: string;
+};
+
+export async function runSync(workspaceId: string): Promise<SyncResult> {
+  const workspace = await prisma.workspace.findUnique({
+    where: { id: workspaceId },
+    include: { syncState: true },
+  });
+
+  if (!workspace) {
+    return { status: "error", notesProcessed: 0, tasksProcessed: 0, conflictsFound: 0, error: "Workspace not found" };
+  }
+
+  if (!isWorkspacePro(workspace) || !isWorkspaceCloud(workspace)) {
+    return { status: "synced", notesProcessed: 0, tasksProcessed: 0, conflictsFound: 0 };
+  }
+
+  const cloudPrisma = getCloudPrisma();
+  if (!cloudPrisma) {
+    return { status: "error", notesProcessed: 0, tasksProcessed: 0, conflictsFound: 0, error: "CLOUD_DATABASE_URL is not configured" };
+  }
+
+  // Refuse to run two syncs for the same workspace at once.
+  if (inFlight.has(workspaceId)) {
+    return { status: "syncing", notesProcessed: 0, tasksProcessed: 0, conflictsFound: 0 };
+  }
+  inFlight.add(workspaceId);
+
+  // Capture the cutoff BEFORE fetching so edits that land mid-run aren't skipped
+  // next time (they'll have updatedAt >= syncStart and get reprocessed).
+  const syncStart = new Date();
+
+  try {
+  const syncState = await getOrCreateSyncState(workspaceId);
+  const lastSyncedAt = syncState.lastSyncedAt ?? new Date(0);
+  const { snapshots, version: snapshotVersion } = await getSnapshots(workspaceId);
+
+  let notesProcessed = 0;
+  let tasksProcessed = 0;
+  let conflictsFound = 0;
+
+  // ── Notes sync ──────────────────────────────────────────────────────────────
+
+  const [localNotes, cloudNotes] = await Promise.all([
+    prisma.note.findMany({ where: { workspaceId }, orderBy: { updatedAt: "asc" } }),
+    cloudPrisma.note.findMany({ where: { workspaceId }, orderBy: { updatedAt: "asc" } }),
+  ]);
+
+  const localNoteMap = new Map(localNotes.map((n) => [n.id, n]));
+  const cloudNoteMap = new Map(cloudNotes.map((n) => [n.id, n]));
+
+  // Notes that changed locally since last sync
+  const localChanged = localNotes.filter((n) => n.updatedAt > lastSyncedAt);
+  // Notes that changed in the cloud since last sync
+  const cloudChanged = cloudNotes.filter((n) => n.updatedAt > lastSyncedAt);
+  const cloudChangedIds = new Set(cloudChanged.map((n) => n.id));
+
+  for (const localNote of localChanged) {
+    if (await isTombstoned(workspaceId, "note", localNote.id)) continue;
+
+    const cloudNote = cloudNoteMap.get(localNote.id);
+
+    // Note content is encrypted symmetrically (same pepper + workspace salt) so
+    // ciphertext is portable between DBs as-is; only the merge needs plaintext.
+    if (!cloudNote) {
+      // New locally — push to cloud (upsert: tolerate a racing prior insert)
+      await cloudPrisma.note.upsert({
+        where: { id: localNote.id },
+        create: {
+          id: localNote.id,
+          workspaceId: localNote.workspaceId,
+          title: localNote.title,
+          content: localNote.content,
+          version: localNote.version,
+          deviceId: localNote.deviceId,
+          createdAt: localNote.createdAt,
+          updatedAt: localNote.updatedAt,
+        },
+        update: {
+          title: localNote.title,
+          content: localNote.content,
+          version: localNote.version,
+          updatedAt: localNote.updatedAt,
+        },
+      });
+      snapshots[localNote.id] = await decryptFromSync(localNote.content, workspaceId);
+      notesProcessed++;
+      continue;
+    }
+
+    if (!cloudChangedIds.has(localNote.id)) {
+      // Only local changed — push update to cloud
+      await cloudPrisma.note.update({
+        where: { id: localNote.id },
+        data: {
+          title: localNote.title,
+          content: localNote.content,
+          version: localNote.version,
+          updatedAt: localNote.updatedAt,
+        },
+      });
+      snapshots[localNote.id] = await decryptFromSync(localNote.content, workspaceId);
+      notesProcessed++;
+      continue;
+    }
+
+    // Both changed — three-way merge on plaintext, then re-encrypt for storage.
+    const base = snapshots[localNote.id] ?? "";
+    const localPlain = await decryptFromSync(localNote.content, workspaceId);
+    const cloudPlain = await decryptFromSync(cloudNote.content, workspaceId);
+    const result = threeWayMerge(base, localPlain, cloudPlain);
+
+    if (!result.hasConflicts) {
+      const nextVersion = Math.max(localNote.version, cloudNote.version) + 1;
+      const mergedCipher = await encryptForSync(result.merged, workspaceId);
+      await Promise.all([
+        prisma.note.update({
+          where: { id: localNote.id },
+          data: { content: mergedCipher, version: nextVersion },
+        }),
+        cloudPrisma.note.update({
+          where: { id: localNote.id },
+          data: { content: mergedCipher, version: nextVersion, updatedAt: new Date() },
+        }),
+      ]);
+      snapshots[localNote.id] = result.merged;
+    } else {
+      // Store ciphertext in the conflict log; the conflicts API decrypts for display.
+      await logConflict(workspaceId, "note", localNote.id, localNote.content, cloudNote.content);
+      conflictsFound++;
+    }
+    notesProcessed++;
+  }
+
+  // Notes new in cloud — pull down to local
+  for (const cloudNote of cloudChanged) {
+    if (localNoteMap.has(cloudNote.id)) continue; // already handled above
+    if (await isTombstoned(workspaceId, "note", cloudNote.id)) continue;
+
+    await prisma.note.upsert({
+      where: { id: cloudNote.id },
+      create: {
+        id: cloudNote.id,
+        workspaceId: cloudNote.workspaceId,
+        title: cloudNote.title,
+        content: cloudNote.content,
+        version: cloudNote.version,
+        deviceId: cloudNote.deviceId,
+        createdAt: cloudNote.createdAt,
+        updatedAt: cloudNote.updatedAt,
+      },
+      update: {
+        title: cloudNote.title,
+        content: cloudNote.content,
+        version: cloudNote.version,
+        updatedAt: cloudNote.updatedAt,
+      },
+    });
+    snapshots[cloudNote.id] = await decryptFromSync(cloudNote.content, workspaceId);
+    notesProcessed++;
+  }
+
+  // ── Tasks sync ───────────────────────────────────────────────────────────────
+
+  const [localTasks, cloudTasks] = await Promise.all([
+    prisma.task.findMany({ where: { workspaceId, updatedAt: { gt: lastSyncedAt } } }),
+    cloudPrisma.task.findMany({ where: { workspaceId, updatedAt: { gt: lastSyncedAt } } }),
+  ]);
+
+  const localTaskMap = new Map(localTasks.map((t) => [t.id, t]));
+  const cloudTaskMap = new Map(cloudTasks.map((t) => [t.id, t]));
+
+  // Push locally changed tasks to cloud
+  for (const localTask of localTasks) {
+    if (await isTombstoned(workspaceId, "task", localTask.id)) continue;
+
+    const cloudTask = cloudTaskMap.get(localTask.id);
+
+    if (!cloudTask) {
+      await cloudPrisma.task.upsert({
+        where: { id: localTask.id },
+        create: {
+          id: localTask.id,
+          workspaceId: localTask.workspaceId,
+          noteId: localTask.noteId,
+          title: localTask.title,
+          status: localTask.status,
+          assigneeType: localTask.assigneeType,
+          assigneeId: localTask.assigneeId,
+          fileRefs: localTask.fileRefs,
+          version: localTask.version,
+          createdAt: localTask.createdAt,
+          updatedAt: localTask.updatedAt,
+        },
+        update: {
+          status: localTask.status,
+          version: localTask.version,
+          updatedAt: localTask.updatedAt,
+        },
+      });
+      tasksProcessed++;
+      continue;
+    }
+
+    const winner = lastWriteWins(
+      { id: localTask.id, updatedAt: localTask.updatedAt, version: localTask.version },
+      { id: cloudTask.id, updatedAt: cloudTask.updatedAt, version: cloudTask.version }
+    );
+
+    if (winner === "local") {
+      await cloudPrisma.task.update({
+        where: { id: localTask.id },
+        data: { status: localTask.status, version: localTask.version, updatedAt: localTask.updatedAt },
+      });
+    } else {
+      await prisma.task.update({
+        where: { id: localTask.id },
+        data: { status: cloudTask.status, version: cloudTask.version },
+      });
+    }
+    tasksProcessed++;
+  }
+
+  // Pull tasks new in cloud that don't exist locally
+  for (const cloudTask of cloudTasks) {
+    if (localTaskMap.has(cloudTask.id)) continue;
+    if (await isTombstoned(workspaceId, "task", cloudTask.id)) continue;
+
+    await prisma.task.upsert({
+      where: { id: cloudTask.id },
+      create: {
+        id: cloudTask.id,
+        workspaceId: cloudTask.workspaceId,
+        noteId: cloudTask.noteId,
+        title: cloudTask.title,
+        status: cloudTask.status,
+        assigneeType: cloudTask.assigneeType,
+        assigneeId: cloudTask.assigneeId,
+        fileRefs: cloudTask.fileRefs,
+        version: cloudTask.version,
+        createdAt: cloudTask.createdAt,
+        updatedAt: cloudTask.updatedAt,
+      },
+      update: {
+        status: cloudTask.status,
+        version: cloudTask.version,
+        updatedAt: cloudTask.updatedAt,
+      },
+    });
+    tasksProcessed++;
+  }
+
+  // ── Finalize ─────────────────────────────────────────────────────────────────
+
+  await saveSnapshots(workspaceId, snapshots, snapshotVersion);
+  await prisma.syncState.update({
+    where: { workspaceId },
+    data: {
+      // Use the pre-fetch cutoff so writes during the run are picked up next time.
+      lastSyncedAt: syncStart,
+      localVersion: { increment: 1 },
+      cloudVersion: { increment: 1 },
+    },
+  });
+
+  const status: SyncStatus = conflictsFound > 0 ? "conflict" : "synced";
+  return { status, notesProcessed, tasksProcessed, conflictsFound };
+  } finally {
+    inFlight.delete(workspaceId);
+  }
+}
+
+// ── Per-device helpers (called by devices pushing a single change) ────────────
+
+export async function syncNoteConflict(
+  workspaceId: string,
+  noteId: string,
+  incomingContent: string,
+  incomingDeviceId: string
+): Promise<{ autoResolved: boolean; conflictId?: string }> {
+  const note = await prisma.note.findUnique({ where: { id: noteId } });
+  if (!note) return { autoResolved: false };
+
+  if (await isTombstoned(workspaceId, "note", noteId)) {
+    return { autoResolved: true };
+  }
+
+  const { snapshots } = await getSnapshots(workspaceId);
+  const base = snapshots[noteId] ?? "";
+
+  // incomingContent is plaintext from the pushing device; note.content is ciphertext.
+  const currentPlain = await decryptFromSync(note.content, workspaceId);
+  if (incomingContent === currentPlain) {
+    return { autoResolved: true };
+  }
+
+  const result = threeWayMerge(base, currentPlain, incomingContent);
+
+  if (!result.hasConflicts) {
+    const mergedCipher = await encryptForSync(result.merged, workspaceId);
+    await prisma.note.update({
+      where: { id: noteId },
+      data: { content: mergedCipher, version: { increment: 1 }, deviceId: incomingDeviceId },
+    });
+    await saveSnapshot(workspaceId, noteId, result.merged);
+    return { autoResolved: true };
+  }
+
+  // Log ciphertext for both sides (conflicts API decrypts for display).
+  const incomingCipher = await encryptForSync(incomingContent, workspaceId);
+  const conflictId = await logConflict(workspaceId, "note", noteId, note.content, incomingCipher);
+  return { autoResolved: false, conflictId };
+}
+
+export async function syncTaskUpdate(
+  workspaceId: string,
+  taskId: string,
+  incomingStatus: string,
+  incomingUpdatedAt: Date
+): Promise<"applied" | "rejected" | "tombstoned"> {
+  if (await isTombstoned(workspaceId, "task", taskId)) return "tombstoned";
+
+  const task = await prisma.task.findUnique({ where: { id: taskId } });
+  if (!task) return "rejected";
+
+  const winner = lastWriteWins(
+    { id: task.id, updatedAt: task.updatedAt, version: task.version },
+    { id: taskId, updatedAt: incomingUpdatedAt, version: task.version }
+  );
+
+  if (winner === "cloud") {
+    await prisma.task.update({
+      where: { id: taskId },
+      data: { status: incomingStatus as never, version: { increment: 1 } },
+    });
+    return "applied";
+  }
+
+  return "rejected";
+}

package/lib/task-parser.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from "vitest";
+import { parseTasksFromMarkdown, isAgentHandle } from "@/lib/task-parser";
+
+describe("parseTasksFromMarkdown", () => {
+  it("parses a basic task with assignee", () => {
+    const [t] = parseTasksFromMarkdown("- [ ] ship docs @alice");
+    expect(t.title).toBe("ship docs");
+    expect(t.assigneeHandle).toBe("@alice");
+    expect(t.isChecked).toBe(false);
+  });
+
+  it("detects checked tasks", () => {
+    const [t] = parseTasksFromMarkdown("- [x] done thing");
+    expect(t.isChecked).toBe(true);
+    expect(t.title).toBe("done thing");
+  });
+
+  it("parses unordered asterisk task items", () => {
+    const [t] = parseTasksFromMarkdown(
+      "* [ ] review spec @bob !medium 2026-06-01..2026-06-05 <spec.md>"
+    );
+
+    expect(t).toEqual(
+      expect.objectContaining({
+        title: "review spec",
+        assigneeHandle: "@bob",
+        isChecked: false,
+        priority: "MEDIUM",
+        startDate: "2026-06-01",
+        dueDate: "2026-06-05",
+        fileRefs: ["spec.md"],
+      })
+    );
+  });
+
+  it("parses ordered task items", () => {
+    const [t] = parseTasksFromMarkdown(
+      "1. [ ] ship release notes @alice !high 2026-06-14..2026-06-20 <notes.md>"
+    );
+
+    expect(t).toEqual(
+      expect.objectContaining({
+        title: "ship release notes",
+        assigneeHandle: "@alice",
+        isChecked: false,
+        priority: "HIGH",
+        startDate: "2026-06-14",
+        dueDate: "2026-06-20",
+        fileRefs: ["notes.md"],
+      })
+    );
+  });
+
+  it("strips refs, mentions, filerefs, and date ranges from the title", () => {
+    const [t] = parseTasksFromMarkdown("- [ ] review [[Spec]] ((Task)) @bob <file.md> 2026-06-01..2026-06-05");
+    expect(t.title).toBe("review");
+    expect(t.startDate).toBe("2026-06-01");
+    expect(t.dueDate).toBe("2026-06-05");
+    expect(t.fileRefs).toEqual(["file.md"]);
+  });
+
+  it("parses checked tasks with priority and dates", () => {
+    const tasks = parseTasksFromMarkdown(
+      "- [x] Ship MCP docs @agent !high 2026-06-14..2026-06-20 <app/mcp/route.tsx>"
+    );
+
+    expect(tasks).toEqual([
+      expect.objectContaining({
+        isChecked: true,
+        priority: "HIGH",
+        startDate: "2026-06-14",
+        dueDate: "2026-06-20",
+      }),
+    ]);
+  });
+
+  it("keeps a lone date as the title when nothing else remains", () => {
+    const [t] = parseTasksFromMarkdown("- [ ] 2026-05-20");
+    expect(t.title).toBe("2026-05-20");
+  });
+
+  it("ignores non-task lines", () => {
+    expect(parseTasksFromMarkdown("# heading\njust text")).toHaveLength(0);
+  });
+
+  it("recognises only @agent as the agent handle", () => {
+    expect(isAgentHandle("@agent")).toBe(true);
+    expect(isAgentHandle("@AGENT")).toBe(true);
+    expect(isAgentHandle("@alice")).toBe(false);
+  });
+});

package/lib/task-parser.ts

@@ -0,0 +1,81 @@
+export type ParsedTask = {
+  title: string;
+  assigneeHandle: string | null;
+  fileRefs: string[];
+  lineIndex: number;
+  isChecked: boolean;
+  startDate: string | null; // ISO date YYYY-MM-DD — start of a date range
+  dueDate: string | null;   // ISO date YYYY-MM-DD — due date or end of range
+  priority: string | null;  // Prisma Priority enum value (e.g. "HIGH") or null for default
+};
+
+const TASK_REGEX = /^(\s*)(?:[-*]|\d+\.)\s+\[([ x])\]\s+(.+)$/;
+const MENTION_REGEX = /@([\w-]+)/g;
+const FILEREF_REGEX = /<([^>]+)>/g;
+const PRIORITY_REGEX = /!(low|medium|high|critical)\b/i;
+// Range: 2026-06-01..2026-06-05  — single: 2026-06-01
+// No \b anchors: the - inside dates is \W so \b fires mid-date and breaks matching.
+const DATE_RANGE_REGEX = /(\d{4}-\d{2}-\d{2})\.\.(\d{4}-\d{2}-\d{2})/;
+const DATE_REGEX       = /(\d{4}-\d{2}-\d{2})/;
+
+export function parseTasksFromMarkdown(content: string): ParsedTask[] {
+  const lines = content.split("\n");
+  const tasks: ParsedTask[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const match = TASK_REGEX.exec(lines[i]);
+    if (!match) continue;
+
+    const checked = match[2] === "x";
+    const text = match[3];
+
+    const mentionMatch = text.match(MENTION_REGEX);
+    const assigneeHandle = mentionMatch ? mentionMatch[0] : null;
+
+    const fileRefs: string[] = [];
+    let fileMatch: RegExpExecArray | null;
+    const fileRegex = new RegExp(FILEREF_REGEX.source, "g");
+    while ((fileMatch = fileRegex.exec(text)) !== null) {
+      fileRefs.push(fileMatch[1]);
+    }
+
+    // Try range first (2026-06-01..2026-06-05), then single date
+    const rangeMatch = DATE_RANGE_REGEX.exec(text);
+    const singleMatch = rangeMatch ? null : DATE_REGEX.exec(text);
+
+    const parsedStartDate = rangeMatch ? rangeMatch[1] : null;
+    const parsedDueDate   = rangeMatch ? rangeMatch[2] : (singleMatch ? singleMatch[1] : null);
+
+    const priorityMatch = PRIORITY_REGEX.exec(text);
+    const priority = priorityMatch ? priorityMatch[1].toUpperCase() : null;
+
+    const titleCandidate = text
+      .replace(/\[\[[^\]]*\]\]/g, "")   // strip [[note refs]]
+      .replace(/\(\([^)]*\)\)/g, "")    // strip ((task refs))
+      .replace(MENTION_REGEX, "")
+      .replace(FILEREF_REGEX, "")
+      .replace(DATE_RANGE_REGEX, "")
+      .replace(DATE_REGEX, "")
+      .replace(/!(low|medium|high|critical)\b/gi, "")
+      .replace(/\s*<!--task::[A-Z_]+-->/g, "")
+      .trim();
+
+    // If stripping dates leaves an empty title, keep the date string as the
+    // title so the task still gets created (e.g. "- [ ] 2026-05-20").
+    const hasRealTitle = titleCandidate.length > 0;
+    const startDate = hasRealTitle ? parsedStartDate : null;
+    const dueDate   = hasRealTitle ? parsedDueDate   : null;
+    const title     = hasRealTitle ? titleCandidate  : (parsedDueDate ?? parsedStartDate ?? "");
+
+    if (!title) continue; // truly empty — skip
+
+    tasks.push({ title, assigneeHandle, fileRefs, lineIndex: i, isChecked: checked, startDate, dueDate, priority });
+  }
+
+  return tasks;
+}
+
+// Only @agent is valid — identity tracked via MCP token, not handle name
+export function isAgentHandle(handle: string): boolean {
+  return handle.toLowerCase() === "@agent";
+}

package/lib/task-utils.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared utility functions for task operations
+ */
+
+export interface TaskWithDueDate {
+  dueDate: string | Date | null;
+  status?: string;
+}
+
+/**
+ * Check if a task is overdue.
+ * Compares dates in local timezone (ignoring time component).
+ * Returns false if task has no due date or is already done.
+ */
+export function isOverdue(task: TaskWithDueDate): boolean {
+  if (!task.dueDate || task.status === "DONE") return false;
+
+  // Compare dates in local timezone, ignoring time component
+  const due = new Date(task.dueDate);
+  const today = new Date();
+
+  // Reset time components for pure date comparison
+  due.setHours(0, 0, 0, 0);
+  today.setHours(0, 0, 0, 0);
+
+  return due < today;
+}
+
+/**
+ * Format a date for display relative to now (e.g., "3 days ago")
+ */
+export function formatRelativeTime(date: string | Date): string {
+  const now = new Date();
+  const then = new Date(date);
+  const diffMs = now.getTime() - then.getTime();
+  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+
+  if (diffDays === 0) {
+    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+    if (diffHours === 0) {
+      const diffMinutes = Math.floor(diffMs / (1000 * 60));
+      return diffMinutes <= 1 ? "just now" : `${diffMinutes} minutes ago`;
+    }
+    return diffHours === 1 ? "1 hour ago" : `${diffHours} hours ago`;
+  }
+
+  if (diffDays === 1) return "yesterday";
+  if (diffDays < 7) return `${diffDays} days ago`;
+  if (diffDays < 30) return `${Math.floor(diffDays / 7)} weeks ago`;
+  if (diffDays < 365) return `${Math.floor(diffDays / 30)} months ago`;
+  return `${Math.floor(diffDays / 365)} years ago`;
+}

package/lib/use-is-electron.ts

@@ -0,0 +1,19 @@
+"use client";
+
+import { useState, useEffect } from "react";
+
+/**
+ * Returns `true` when running inside the Electron desktop app.
+ * Detection relies on `window.electronAPI` which is exposed by
+ * `electron/preload.ts` via `contextBridge.exposeInMainWorld`.
+ * SSR-safe: returns `false` on the server and hydrates to the correct value.
+ */
+export function useIsElectron() {
+  const [isElectron, setIsElectron] = useState(false);
+
+  useEffect(() => {
+    setIsElectron(typeof window !== "undefined" && "electronAPI" in window);
+  }, []);
+
+  return isElectron;
+}

package/lib/use-is-mobile.ts

@@ -0,0 +1,22 @@
+"use client";
+
+import { useState, useEffect } from "react";
+
+/**
+ * Returns `true` when the viewport is narrower than the mobile breakpoint.
+ * Uses `matchMedia` so it updates live on resize / orientation change.
+ * SSR-safe: returns `false` on the server and hydrates to the correct value.
+ */
+export function useIsMobile() {
+  const [isMobile, setIsMobile] = useState(false);
+
+  useEffect(() => {
+    const mq = window.matchMedia("(max-width: 767.98px)");
+    const update = () => setIsMobile(mq.matches);
+    update();
+    mq.addEventListener("change", update);
+    return () => mq.removeEventListener("change", update);
+  }, []);
+
+  return isMobile;
+}

package/lib/validation/calendar-feed.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { MAX_FEED_LABEL_LEN, FEED_COLOR_KEYS, DEFAULT_FEED_COLOR } from "@/lib/limits";
+
+const urlSchema = z
+  .string()
+  .url("must be a valid URL")
+  .refine((u) => u.startsWith("https://"), "must be an https:// URL");
+
+const colorSchema = z.enum(FEED_COLOR_KEYS as unknown as [string, ...string[]]).default(DEFAULT_FEED_COLOR);
+
+export const createFeedSchema = z.object({
+  label: z
+    .string()
+    .trim()
+    .min(1, "label is required")
+    .max(MAX_FEED_LABEL_LEN, `label must be ≤ ${MAX_FEED_LABEL_LEN} chars`),
+  url: urlSchema,
+  color: colorSchema.optional(),
+});
+
+export const updateFeedSchema = z.object({
+  label: z
+    .string()
+    .trim()
+    .min(1, "label is required")
+    .max(MAX_FEED_LABEL_LEN, `label must be ≤ ${MAX_FEED_LABEL_LEN} chars`)
+    .optional(),
+  url: urlSchema.optional(),
+  color: z.enum(FEED_COLOR_KEYS as unknown as [string, ...string[]]).optional(),
+  enabled: z.boolean().optional(),
+});