@knotpad/app 0.1.5 → 0.1.6

package/lib/note-sync.ts

@@ -0,0 +1,201 @@
+/**
+ * Helpers for keeping notes ↔ tasks in sync.
+ * - Snapshot management (base content for three-way merge)
+ * - Note badge updates when task status changes
+ * - Re-parse note content into tasks after edits
+ */
+
+import { prisma } from "@/lib/prisma";
+import type { PrismaClient, Priority } from "@/app/generated/prisma/client";
+import { parseTasksFromMarkdown } from "@/lib/task-parser";
+import { resolveAssignee } from "@/lib/mentions";
+import { encryptForSync, decryptFromSync } from "@/lib/note-crypto";
+
+// --- Snapshot store (noteSnapshots field in SyncState) ---
+
+type Snapshots = Record<string, string>; // noteId → content
+
+export async function getOrCreateSyncState(workspaceId: string, db: PrismaClient = prisma) {
+  const existing = await db.syncState.findUnique({ where: { workspaceId } });
+  if (existing) return existing;
+  return db.syncState.create({ data: { workspaceId } });
+}
+
+export async function getSnapshots(
+  workspaceId: string,
+  db: PrismaClient = prisma
+): Promise<{ snapshots: Snapshots; version: number }> {
+  const state = await db.syncState.findUnique({ where: { workspaceId } });
+  const version = state?.snapshotVersion ?? 0;
+  if (!state?.noteSnapshots) return { snapshots: {}, version };
+  try {
+    // Snapshots hold note content (the three-way-merge base), so the JSON blob
+    // is encrypted at rest. Values inside the parsed map are plaintext.
+    const json = await decryptFromSync(state.noteSnapshots, workspaceId);
+    return { snapshots: JSON.parse(json) as Snapshots, version };
+  } catch {
+    return { snapshots: {}, version };
+  }
+}
+
+export async function saveSnapshots(
+  workspaceId: string,
+  snapshots: Snapshots,
+  expectedVersion?: number,
+  db: PrismaClient = prisma
+): Promise<void> {
+  const blob = await encryptForSync(JSON.stringify(snapshots), workspaceId);
+
+  if (expectedVersion !== undefined) {
+    // Optimistic concurrency: only write if the version hasn't changed since we read.
+    // Protects against concurrent writes from multiple Node.js instances (cloud mode).
+    const updated = await db.syncState.updateMany({
+      where: { workspaceId, snapshotVersion: expectedVersion },
+      data: { noteSnapshots: blob, snapshotVersion: { increment: 1 } },
+    });
+    if (updated.count === 0) {
+      throw new Error("Snapshot version conflict — another process updated concurrently");
+    }
+    return;
+  }
+
+  await db.syncState.upsert({
+    where: { workspaceId },
+    update: { noteSnapshots: blob, snapshotVersion: { increment: 1 } },
+    create: { workspaceId, noteSnapshots: blob, snapshotVersion: 1 },
+  });
+}
+
+// Per-workspace serialization: getSnapshots → mutate → saveSnapshots is a
+// read-modify-write of one JSON blob, so concurrent single-note updates within
+// this process would clobber each other. Chain them per workspace.
+// For multi-instance protection, saveSnapshots uses optimistic concurrency.
+const snapshotChains = new Map<string, Promise<unknown>>();
+
+function withSnapshotLock<T>(workspaceId: string, fn: () => Promise<T>): Promise<T> {
+  const prev = snapshotChains.get(workspaceId) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  // Keep the chain alive but don't let rejections poison the next caller.
+  snapshotChains.set(workspaceId, next.catch(() => {}));
+  return next;
+}
+
+export async function saveSnapshot(
+  workspaceId: string,
+  noteId: string,
+  content: string,
+  db: PrismaClient = prisma
+): Promise<void> {
+  await withSnapshotLock(workspaceId, async () => {
+    const { snapshots, version } = await getSnapshots(workspaceId, db);
+    snapshots[noteId] = content;
+    await saveSnapshots(workspaceId, snapshots, version, db);
+  });
+}
+
+export async function deleteSnapshot(
+  workspaceId: string,
+  noteId: string,
+  db: PrismaClient = prisma
+): Promise<void> {
+  await withSnapshotLock(workspaceId, async () => {
+    const { snapshots, version } = await getSnapshots(workspaceId, db);
+    delete snapshots[noteId];
+    await saveSnapshots(workspaceId, snapshots, version, db);
+  });
+}
+
+// --- Note badge update (inline status markers) ---
+
+const STATUS_COMMENT_RE = /\s*<!--task::[^>]*-->/g;
+const TASK_LINE_RE = /^(\s*)-\s+\[([ x])\]\s+(.+)$/;
+
+export async function updateNoteBadge(
+  noteId: string,
+  taskTitle: string,
+  newStatus: string,
+  db: PrismaClient = prisma
+): Promise<void> {
+  const note = await db.note.findUnique({ where: { id: noteId } });
+  if (!note) return;
+
+  const plain = await decryptFromSync(note.content, note.workspaceId);
+  const lines = plain.split("\n");
+  let changed = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const m = TASK_LINE_RE.exec(lines[i]);
+    if (!m) continue;
+
+    const lineTitle = m[3]
+      .replace(/@[\w-]+/g, "")
+      .replace(/<[^>]+>/g, "")
+      .replace(STATUS_COMMENT_RE, "")
+      .trim();
+
+    if (lineTitle !== taskTitle) continue;
+
+    // Flip the checkbox only; <!--task::STATUS--> comments are no longer written
+    // (nothing reads them and they caused spurious sync diffs).
+    const stripped = lines[i].replace(STATUS_COMMENT_RE, "");
+    const checkbox = newStatus === "DONE" ? "x" : " ";
+    const next = stripped.replace(/\[([ x])\]/, `[${checkbox}]`);
+    if (next !== lines[i]) { lines[i] = next; changed = true; }
+    break;
+  }
+
+  if (changed) {
+    const stored = await encryptForSync(lines.join("\n"), note.workspaceId);
+    await db.note.update({
+      where: { id: noteId },
+      data: { content: stored, version: { increment: 1 } },
+    });
+  }
+}
+
+// --- Re-parse note content → sync tasks (idempotent) ---
+
+export async function syncNoteToTasks(
+  noteId: string,
+  workspaceId: string,
+  db: PrismaClient = prisma
+): Promise<void> {
+  const note = await db.note.findUnique({
+    where: { id: noteId },
+    include: { tasks: true },
+  });
+  if (!note) return;
+
+  const plain = await decryptFromSync(note.content, workspaceId);
+  const parsed = parseTasksFromMarkdown(plain);
+  const existingByTitle = new Map(note.tasks.map((t) => [t.title, t]));
+
+  await db.$transaction(async (tx) => {
+    for (const p of parsed) {
+      if (existingByTitle.has(p.title)) {
+        existingByTitle.delete(p.title);
+        continue; // already exists, idempotent
+      }
+
+      const { assigneeId, assigneeType } = await resolveAssignee(tx, workspaceId, p.assigneeHandle);
+
+      const task = await tx.task.create({
+        data: {
+          title: p.title,
+          noteId,
+          workspaceId,
+          assigneeType,
+          assigneeId,
+          fileRefs: p.fileRefs,
+          ...(p.priority && { priority: p.priority as Priority }),
+        },
+      });
+
+      // Snippet is intentionally empty — computed from decrypted note content at
+      // read time (task-detail page) so no plaintext leaks into the DB.
+      await tx.taskReference.create({
+        data: { taskId: task.id, noteId, snippet: "" },
+      });
+    }
+  });
+}

package/lib/note-title.ts

@@ -0,0 +1,93 @@
+// Extract a human-readable title from raw markdown content.
+// Strips common markdown syntax and returns the first meaningful sentence,
+// capped at 80 characters so it fits nicely in sidebars and card labels.
+
+const MAX_AUTO_TITLE_LEN = 80;
+
+export function extractTitleFromContent(content: string): string | null {
+  if (!content || !content.trim()) return null;
+
+  const lines = content.split("\n");
+  for (const raw of lines) {
+    let line = raw.trim();
+    if (!line) continue;
+
+    // Strip heading markers
+    line = line.replace(/^#{1,6}\s*/, "");
+
+    // Strip task checkbox prefix
+    line = line.replace(/^\s*-\s+\[[ x]\]\s*/, "");
+
+    // Strip bold / italic / strikethrough markers
+    line = line.replace(/(\*{1,2}|_{1,2}|~{2})([^*_~]+)\1/g, "$2");
+
+    // Strip inline code backticks
+    line = line.replace(/`([^`]+)`/g, "$1");
+
+    // Strip markdown links → keep only the text part
+    line = line.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+
+    // Strip bare URLs
+    line = line.replace(/https?:\/\/\S+/g, "");
+
+    // Strip HTML tags
+    line = line.replace(/<[^>]+>/g, "");
+
+    // Strip image syntax
+    line = line.replace(/!\[[^\]]*\]\([^)]+\)/g, "");
+
+    // Strip note/task refs
+    line = line.replace(/\[\[[^\]]+\]\]/g, "");
+    line = line.replace(/\(\([^)]+\)\)/g, "");
+
+    // Strip mention handles
+    line = line.replace(/@[\w-]+/g, "");
+
+    // Strip file references <...>
+    line = line.replace(/<[^>]+>/g, "");
+
+    // Strip date/date-ranges
+    line = line.replace(/\d{4}-\d{2}-\d{2}(\.\.\d{4}-\d{2}-\d{2})?/g, "");
+
+    // Strip remaining markdown list markers
+    line = line.replace(/^(\s*[-*+]|\d+\.)\s+/, "");
+
+    // Clean up whitespace
+    line = line.replace(/\s+/g, " ").trim();
+
+    if (!line) continue;
+
+    // Cap length at first sentence boundary if possible, otherwise first 4 words
+    let title = line;
+    const sentenceEnd = title.search(/[.!?](\s|$)/);
+    if (sentenceEnd !== -1 && sentenceEnd > 0) {
+      title = title.slice(0, sentenceEnd + 1);
+    } else {
+      // No punctuation — grab the first 4 words
+      const words = title.split(" ");
+      if (words.length > 4) {
+        title = words.slice(0, 4).join(" ");
+      }
+    }
+    if (title.length > MAX_AUTO_TITLE_LEN) {
+      title = title.slice(0, MAX_AUTO_TITLE_LEN);
+      // Don't chop mid-word
+      const lastSpace = title.lastIndexOf(" ");
+      if (lastSpace > 20) title = title.slice(0, lastSpace);
+    }
+
+    title = title.trim();
+    if (title) return title;
+  }
+
+  return null;
+}
+
+export function autoTitle(content: string, currentTitle?: string): string {
+  // Only auto-title if the user hasn't explicitly named it
+  if (currentTitle && currentTitle.trim() && currentTitle.trim() !== "Untitled") {
+    return currentTitle.trim();
+  }
+  const extracted = extractTitleFromContent(content);
+  return extracted ?? "Untitled";
+}

package/lib/prisma.ts

@@ -0,0 +1,193 @@
+/**
+ * Prisma client factory.
+ *
+ * IS_CLOUD=true  (VPS / SaaS)
+ *   prisma      → Neon (DATABASE_URL)  — all data lives in cloud
+ *   cloudPrisma → same Neon client     — re-exported for sync layer compatibility
+ *
+ * IS_CLOUD=false (npx / local)
+ *   prisma      → PGlite (file-based, .brief/db/)
+ *   cloudPrisma → Neon (CLOUD_DATABASE_URL) or null (free tier, no cloud)
+ *
+ * Initialization:
+ *   Cloud mode  — synchronous, happens at module load
+ *   Local mode  — async (PGlite uses dynamic import); call initLocalPrisma()
+ *                 from instrumentation.ts before requests start
+ *
+ * Callers that need cloudPrisma should guard: if (!getCloudPrisma()) return;
+ */
+
+import { PrismaClient } from "@/app/generated/prisma/client";
+import { PrismaPg } from "@prisma/adapter-pg";
+import { Pool } from "pg";
+import { PrismaNeon } from "@prisma/adapter-neon";
+import path from "path";
+
+const IS_CLOUD = process.env.IS_CLOUD === "true";
+
+const g = global as unknown as {
+  briefPrisma: PrismaClient | undefined;
+  briefCloudPrisma: PrismaClient | null | undefined;
+  briefPglite: unknown;
+};
+
+function isNeonUrl(url: string): boolean {
+  return url.includes("neon.tech") || url.includes("neoncloud");
+}
+
+function makePgPool(url: string): Pool {
+  return new Pool({
+    connectionString: url,
+    max: parseInt(process.env.DB_POOL_MAX ?? "10"),
+    idleTimeoutMillis: 30_000,
+    connectionTimeoutMillis: 5_000,
+  });
+}
+
+// ── Cloud mode: synchronous init at module load ───────────────────────────────
+
+if (IS_CLOUD && !g.briefPrisma) {
+  const url = process.env.DATABASE_URL ?? process.env.CLOUD_DATABASE_URL;
+  if (!url) {
+    throw new Error(
+      "[Brief] IS_CLOUD=true requires DATABASE_URL or CLOUD_DATABASE_URL to be set."
+    );
+  }
+
+  let client: PrismaClient;
+  if (isNeonUrl(url)) {
+    // Neon serverless driver — ideal for Vercel serverless (HTTP/WebSocket, no persistent TCP)
+    client = new PrismaClient({
+      adapter: new PrismaNeon({ connectionString: url }),
+    } as never);
+  } else {
+    // Standard pg Pool — for self-hosted Postgres / VPS
+    client = new PrismaClient({
+      adapter: new PrismaPg(makePgPool(url)),
+    } as never);
+  }
+
+  g.briefPrisma = client;
+  g.briefCloudPrisma = client; // same DB in cloud mode
+}
+
+// ── Local mode: async init (called by instrumentation.ts) ────────────────────
+
+export async function initLocalPrisma(): Promise<void> {
+  if (IS_CLOUD || g.briefPrisma) return;
+
+  const { PGlite } = await import("@electric-sql/pglite");
+  const { PrismaPGlite } = await import("pglite-prisma-adapter");
+
+  const dataDir = process.env.BRIEF_DATA_DIR
+    ? path.resolve(process.env.BRIEF_DATA_DIR)
+    : path.join(process.cwd(), ".brief", "db");
+
+  const pglite = new PGlite(dataDir);
+  g.briefPglite = pglite;
+
+  g.briefPrisma = new PrismaClient({
+    adapter: new PrismaPGlite(pglite),
+  } as never);
+
+  const cloudUrl = process.env.CLOUD_DATABASE_URL;
+  g.briefCloudPrisma = cloudUrl
+    ? new PrismaClient({
+        adapter: isNeonUrl(cloudUrl)
+          ? new PrismaNeon({ connectionString: cloudUrl })
+          : new PrismaPg(makePgPool(cloudUrl)),
+      } as never)
+    : null;
+}
+
+// ── Exports ───────────────────────────────────────────────────────────────────
+
+/**
+ * Primary Prisma client.
+ * Local mode → PGlite. Cloud mode → Neon.
+ * Will throw if accessed before initLocalPrisma() resolves in local mode.
+ */
+export const prisma: PrismaClient = new Proxy({} as PrismaClient, {
+  get(_t, prop) {
+    const client = g.briefPrisma;
+    if (!client) {
+      throw new Error(
+        "[Brief] prisma accessed before DB is ready. " +
+        "Ensure instrumentation.ts has completed initLocalPrisma()."
+      );
+    }
+    const val = (client as never as Record<string, unknown>)[prop as string];
+    return typeof val === "function" ? val.bind(client) : val;
+  },
+});
+
+/**
+ * Cloud Prisma client (Neon).
+ * Always use getCloudPrisma() rather than this constant — it correctly
+ * reflects null (free tier / no cloud) vs a live client (Pro / cloud mode).
+ *
+ * @deprecated prefer getCloudPrisma()
+ */
+export const cloudPrisma: PrismaClient | null = new Proxy(
+  {} as PrismaClient,
+  {
+    get(_t, prop) {
+      return (g.briefCloudPrisma as never as Record<string, unknown>)?.[prop as string];
+    },
+  }
+) as unknown as PrismaClient | null;
+
+/**
+ * Returns the cloud Prisma client, or null if cloud is not configured.
+ * Use this for all null-checks:
+ *   const cloud = getCloudPrisma();
+ *   if (!cloud) return; // free tier
+ */
+export function getCloudPrisma(): PrismaClient | null {
+  return g.briefCloudPrisma ?? null;
+}
+
+/**
+ * Returns the appropriate Prisma client for a workspace:
+ *  - Pro workspace + cloud configured → Neon (cloud-first)
+ *  - Free workspace or no cloud → PGlite (local)
+ *  - IS_CLOUD=true deployments → prisma IS Neon; getCloudPrisma() returns null
+ *    so this returns prisma (correct — already cloud)
+ *
+ * Always reads workspace flags from local PGlite, which is the authoritative
+ * source for plan state (billing webhook writes there).
+ */
+export async function getPrimaryDb(workspaceId: string): Promise<PrismaClient> {
+  const cloud = getCloudPrisma();
+  if (!cloud) return prisma;
+
+  const ws = await prisma.workspace.findUnique({
+    where: { id: workspaceId },
+    select: { isPro: true, isCloud: true },
+  });
+
+  return ws?.isPro && ws?.isCloud ? cloud : prisma;
+}
+
+/**
+ * True if a Prisma/fetch error indicates the cloud DB is unreachable.
+ * Used by API routes to fall back to the local PGlite write buffer.
+ */
+export function isConnectionError(err: unknown): boolean {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    if (
+      msg.includes("can't reach database") ||
+      msg.includes("connection refused") ||
+      msg.includes("econnrefused") ||
+      msg.includes("etimedout") ||
+      msg.includes("connection timed out") ||
+      msg.includes("server has closed the connection")
+    ) {
+      return true;
+    }
+  }
+  const code = (err as { code?: string }).code;
+  // Prisma connectivity error codes
+  return code === "P1001" || code === "P1002" || code === "P1008" || code === "P1017";
+}