@knotpad/app 0.1.0 → 0.1.1

package/electron/main.ts

@@ -1,251 +0,0 @@
-/**
- * Knotpad Desktop — Electron Main Process
- *
- * 1. Finds an available port
- * 2. Spawns the Next.js server (`next start`) as a child process
- * 3. Opens a BrowserWindow pointed at localhost:<port>
- * 4. Handles auto-updater checks (electron-updater)
- * 5. Manages window lifecycle, deep links, and graceful shutdown
- */
-
-import { app, BrowserWindow, dialog, ipcMain, shell } from "electron";
-import { autoUpdater } from "electron-updater";
-import { spawn, ChildProcess } from "child_process";
-import fs from "fs/promises";
-import path from "path";
-import net from "net";
-
-// ── Constants ──────────────────────────────────────────────────────────────────
-
-const IS_DEV = !app.isPackaged;
-const PKG_DIR = path.resolve(__dirname, "..");
-
-// ── Helpers ────────────────────────────────────────────────────────────────────
-
-function findAvailablePort(startPort = 3000): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.listen(startPort, () => {
-      const port = (server.address() as net.AddressInfo).port;
-      server.close(() => resolve(port));
-    });
-    server.on("error", (err: NodeJS.ErrnoException) => {
-      if (err.code === "EADDRINUSE") {
-        findAvailablePort(startPort + 1).then(resolve, reject);
-      } else {
-        reject(err);
-      }
-    });
-  });
-}
-
-function log(msg: string) {
-  console.log(`[electron-main] ${msg}`);
-}
-
-// ── State ────────────────────────────────────────────────────────────────────────
-
-let mainWindow: BrowserWindow | null = null;
-let serverProcess: ChildProcess | null = null;
-let serverPort = 0;
-
-// ── Next.js Server Lifecycle ─────────────────────────────────────────────────────
-
-async function startNextJsServer(): Promise<number> {
-  const port = await findAvailablePort(3000);
-  serverPort = port;
-  log(`Starting Next.js server on port ${port}…`);
-
-  // In dev we use next dev (if dev script is preferred); in prod use next start
-  const serverCmd = IS_DEV ? "npx" : path.join(PKG_DIR, "node_modules/.bin/next");
-  const serverArgs = IS_DEV
-    ? ["next", "dev", "--port", String(port)]
-    : ["start", "--port", String(port)];
-
-  serverProcess = spawn(serverCmd, serverArgs, {
-    cwd: PKG_DIR,
-    stdio: "pipe",
-    env: {
-      ...process.env,
-      PORT: String(port),
-      // Ensure Electron app uses PGlite local mode by default
-      IS_CLOUD: process.env.IS_CLOUD ?? "false",
-      NEXT_PUBLIC_APP_URL: `http://localhost:${port}`,
-    },
-    windowsHide: true,
-  });
-
-  serverProcess.stdout?.on("data", (data: Buffer) => {
-    process.stdout.write(data);
-  });
-  serverProcess.stderr?.on("data", (data: Buffer) => {
-    process.stderr.write(data);
-  });
-
-  serverProcess.on("exit", (code) => {
-    log(`Next.js server exited with code ${code ?? "unknown"}`);
-    serverProcess = null;
-  });
-
-  // Wait a moment for the server to bind, then verify
-  await new Promise<void>((resolve) => setTimeout(resolve, 2000));
-  return port;
-}
-
-function stopNextJsServer() {
-  if (serverProcess) {
-    log("Stopping Next.js server…");
-    serverProcess.kill("SIGTERM");
-    serverProcess = null;
-  }
-}
-
-// ── Window Management ─────────────────────────────────────────────────────────
-
-async function createWindow() {
-  mainWindow = new BrowserWindow({
-    width: 1400,
-    height: 900,
-    minWidth: 900,
-    minHeight: 600,
-    titleBarStyle: "default",
-    webPreferences: {
-      preload: path.join(__dirname, "preload.js"),
-      contextIsolation: true,
-      nodeIntegration: false,
-      sandbox: true,
-    },
-    show: false, // show after server is ready
-  });
-
-  // Load the Next.js app
-  const url = `http://localhost:${serverPort}`;
-  log(`Loading ${url}`);
-  await mainWindow.loadURL(url);
-
-  mainWindow.show();
-
-  if (IS_DEV) {
-    mainWindow.webContents.openDevTools();
-  }
-
-  // Open external links in the OS browser
-  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
-    shell.openExternal(url);
-    return { action: "deny" };
-  });
-
-  mainWindow.on("closed", () => {
-    mainWindow = null;
-  });
-}
-
-// ── Auto Updater ─────────────────────────────────────────────────────────────────
-
-function setupAutoUpdater() {
-  if (IS_DEV) {
-    log("Auto-updater disabled in development");
-    return;
-  }
-
-  autoUpdater.checkForUpdatesAndNotify();
-
-  autoUpdater.on("update-available", () => {
-    log("Update available — downloading…");
-    if (mainWindow) {
-      mainWindow.webContents.send("update-available");
-    }
-  });
-
-  autoUpdater.on("update-downloaded", () => {
-    log("Update downloaded — ready to install");
-    if (mainWindow) {
-      mainWindow.webContents.send("update-downloaded");
-    }
-  });
-}
-
-// ── IPC Handlers ───────────────────────────────────────────────────────────────
-
-ipcMain.handle("get-app-version", () => app.getVersion());
-
-ipcMain.handle("check-for-updates", async () => {
-  if (IS_DEV) return { updateAvailable: false };
-  const result = await autoUpdater.checkForUpdates();
-  return { updateAvailable: result?.updateInfo?.version !== app.getVersion() };
-});
-
-ipcMain.handle("install-update", () => {
-  autoUpdater.quitAndInstall();
-});
-
-ipcMain.handle("get-is-dev", () => IS_DEV);
-
-ipcMain.handle("quit-app", () => {
-  app.quit();
-});
-
-ipcMain.handle("select-backup-folder", async () => {
-  const result = await dialog.showOpenDialog({
-    properties: ["openDirectory", "createDirectory"],
-  });
-
-  if (result.canceled) return null;
-  return result.filePaths[0] ?? null;
-});
-
-ipcMain.handle(
-  "write-backup-files",
-  async (
-    _event,
-    destinationPath: string,
-    files: Array<{ name: string; bytes: number[] }>
-  ) => {
-    await fs.mkdir(destinationPath, { recursive: true });
-
-    await Promise.all(
-      files.map((file) =>
-        fs.writeFile(path.join(destinationPath, file.name), Buffer.from(file.bytes))
-      )
-    );
-  }
-);
-
-// ── App Lifecycle ──────────────────────────────────────────────────────────────
-
-app.whenReady().then(async () => {
-  log("App ready — starting Next.js server…");
-  await startNextJsServer();
-  await createWindow();
-  setupAutoUpdater();
-});
-
-app.on("window-all-closed", () => {
-  stopNextJsServer();
-  if (process.platform !== "darwin") {
-    app.quit();
-  }
-});
-
-app.on("activate", async () => {
-  if (mainWindow === null) {
-    await createWindow();
-  }
-});
-
-app.on("before-quit", () => {
-  stopNextJsServer();
-});
-
-// Prevent multiple instances
-const gotTheLock = app.requestSingleInstanceLock();
-if (!gotTheLock) {
-  app.quit();
-} else {
-  app.on("second-instance", () => {
-    if (mainWindow) {
-      if (mainWindow.isMinimized()) mainWindow.restore();
-      mainWindow.focus();
-    }
-  });
-}

package/electron/preload.ts

@@ -1,56 +0,0 @@
-/**
- * Knotpad Desktop — Electron Preload Script
- *
- * Securely exposes a minimal API to the renderer process via contextBridge.
- * All IPC calls are typed and validated here.
- */
-
-import { contextBridge, ipcRenderer } from "electron";
-
-export interface ElectronAPI {
-  getAppVersion: () => Promise<string>;
-  checkForUpdates: () => Promise<{ updateAvailable: boolean }>;
-  installUpdate: () => Promise<void>;
-  getIsDev: () => Promise<boolean>;
-  quitApp: () => Promise<void>;
-  selectBackupFolder: () => Promise<string | null>;
-  writeBackupFiles: (
-    destinationPath: string,
-    files: Array<{ name: string; bytes: number[] }>
-  ) => Promise<void>;
-  onUpdateAvailable: (callback: () => void) => () => void;
-  onUpdateDownloaded: (callback: () => void) => () => void;
-}
-
-const api: ElectronAPI = {
-  getAppVersion: () => ipcRenderer.invoke("get-app-version"),
-  checkForUpdates: () => ipcRenderer.invoke("check-for-updates"),
-  installUpdate: () => ipcRenderer.invoke("install-update"),
-  getIsDev: () => ipcRenderer.invoke("get-is-dev"),
-  quitApp: () => ipcRenderer.invoke("quit-app"),
-  selectBackupFolder: () => ipcRenderer.invoke("select-backup-folder"),
-  writeBackupFiles: (destinationPath, files) =>
-    ipcRenderer.invoke("write-backup-files", destinationPath, files),
-
-  onUpdateAvailable: (callback: () => void) => {
-    const handler = () => callback();
-    ipcRenderer.on("update-available", handler);
-    return () => ipcRenderer.removeListener("update-available", handler);
-  },
-
-  onUpdateDownloaded: (callback: () => void) => {
-    const handler = () => callback();
-    ipcRenderer.on("update-downloaded", handler);
-    return () => ipcRenderer.removeListener("update-downloaded", handler);
-  },
-};
-
-contextBridge.exposeInMainWorld("electronAPI", api);
-
-// Type augmentation for the renderer
-
-declare global {
-  interface Window {
-    electronAPI: ElectronAPI;
-  }
-}

package/instrumentation.tsx

@@ -1,23 +0,0 @@
-/**
- * Next.js instrumentation hook — runs once when the server starts,
- * before any request handlers.
- *
- * Local mode (IS_CLOUD=false):
- *   1. Initialise PGlite (async dynamic import + file open)
- *   2. Apply any pending SQL migrations to the local DB
- *
- * Cloud mode (IS_CLOUD=true):
- *   No-op. Prisma clients are synchronously initialised at module load,
- *   and migrations are applied to Neon by the deploy pipeline.
- */
-export async function register() {
-  if (process.env.NEXT_RUNTIME !== "nodejs") return;
-  if (process.env.IS_CLOUD === "true") return;
-
-  const { initLocalPrisma } = await import("./lib/prisma");
-  await initLocalPrisma();
-
-  const g = global as never as Record<string, unknown>;
-  const { runLocalMigrations } = await import("./lib/db-init");
-  await runLocalMigrations(g.briefPglite as Parameters<typeof runLocalMigrations>[0]);
-}

package/lib/api-error.ts

@@ -1,50 +0,0 @@
-import { NextResponse } from "next/server";
-import type { z } from "zod";
-
-/**
- * Standard JSON error shape: `{ error, code? }`. Use across all route handlers
- * so clients can rely on a single contract.
- */
-export function apiError(message: string, status = 400, code?: string) {
-  return NextResponse.json(
-    code ? { error: message, code } : { error: message },
-    { status }
-  );
-}
-
-export const unauthorized = () => apiError("Unauthorized", 401);
-export const noWorkspace = () => apiError("No workspace", 404);
-export const notFound = (message = "Not found") => apiError(message, 404);
-
-type ParseOk<T> = { data: T; response?: undefined };
-type ParseErr = { data?: undefined; response: NextResponse };
-
-/**
- * Parse + validate a JSON request body against a zod schema.
- * On failure returns `{ response }` (a ready-to-return 400) so handlers can do:
- *
- *   const parsed = await parseJson(req, schema);
- *   if (parsed.response) return parsed.response;
- *   const { ... } = parsed.data;
- */
-export async function parseJson<T extends z.ZodTypeAny>(
-  req: Request,
-  schema: T
-): Promise<ParseOk<z.infer<T>> | ParseErr> {
-  let raw: unknown;
-  try {
-    raw = await req.json();
-  } catch {
-    return { response: apiError("Invalid JSON body", 400, "INVALID_JSON") };
-  }
-  const result = schema.safeParse(raw);
-  if (!result.success) {
-    const first = result.error.issues[0];
-    const path = first?.path.join(".");
-    const message = first
-      ? `${path ? path + ": " : ""}${first.message}`
-      : "Invalid request";
-    return { response: apiError(message, 400, "VALIDATION") };
-  }
-  return { data: result.data };
-}

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

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { shouldRunScheduledBackup } from "@/lib/backup/backup-runner";
-
-describe("shouldRunScheduledBackup", () => {
-  it("runs only when the schedule is enabled and due", () => {
-    expect(
-      shouldRunScheduledBackup({
-        isElectron: true,
-        isCloudWorkspace: false,
-        scheduleEnabled: true,
-        destinationPath: "C:/Backups",
-        cadence: "DAILY",
-        lastBackupAt: new Date("2026-06-10T08:00:00.000Z"),
-        now: new Date("2026-06-11T08:01:00.000Z"),
-      })
-    ).toBe(true);
-  });
-
-  it("skips cloud workspaces", () => {
-    expect(
-      shouldRunScheduledBackup({
-        isElectron: true,
-        isCloudWorkspace: true,
-        scheduleEnabled: true,
-        destinationPath: "C:/Backups",
-        cadence: "DAILY",
-        lastBackupAt: null,
-        now: new Date("2026-06-13T00:00:00.000Z"),
-      })
-    ).toBe(false);
-  });
-});

package/lib/backup/backup-runner.ts

@@ -1,19 +0,0 @@
-import { isBackupDue } from "@/lib/backup/backup-schedule";
-import type { BackupCadence } from "@/lib/backup/types";
-
-export function shouldRunScheduledBackup(input: {
-  isElectron: boolean;
-  isCloudWorkspace: boolean;
-  scheduleEnabled: boolean;
-  destinationPath: string | null;
-  cadence: BackupCadence;
-  lastBackupAt: Date | null;
-  now?: Date;
-}) {
-  if (!input.isElectron) return false;
-  if (input.isCloudWorkspace) return false;
-  if (!input.scheduleEnabled) return false;
-  if (!input.destinationPath) return false;
-
-  return isBackupDue(input.cadence, input.lastBackupAt, input.now ?? new Date());
-}

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

@@ -1,23 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getNextBackupDueAt, isBackupDue } from "@/lib/backup/backup-schedule";
-
-describe("backup schedule cadence", () => {
-  it("marks a daily backup due after 24 hours", () => {
-    const lastBackupAt = new Date("2026-06-10T08:00:00.000Z");
-    const now = new Date("2026-06-11T08:01:00.000Z");
-
-    expect(isBackupDue("DAILY", lastBackupAt, now)).toBe(true);
-  });
-
-  it("returns the next monthly due date from the last success time", () => {
-    const lastBackupAt = new Date("2026-01-31T09:00:00.000Z");
-
-    expect(getNextBackupDueAt("MONTHLY", lastBackupAt)?.toISOString()).toBe(
-      "2026-02-28T09:00:00.000Z"
-    );
-  });
-
-  it("treats a missing last backup as immediately due", () => {
-    expect(isBackupDue("WEEKLY", null, new Date("2026-06-13T00:00:00.000Z"))).toBe(true);
-  });
-});

package/lib/backup/backup-schedule.ts

@@ -1,55 +0,0 @@
-import type { BackupCadence } from "@/lib/backup/types";
-
-function getDaysInMonth(year: number, monthIndex: number) {
-  return new Date(Date.UTC(year, monthIndex + 1, 0)).getUTCDate();
-}
-
-function addMonthsClamped(date: Date, monthsToAdd: number) {
-  const year = date.getUTCFullYear();
-  const monthIndex = date.getUTCMonth();
-  const day = date.getUTCDate();
-  const nextMonthIndex = monthIndex + monthsToAdd;
-  const targetYear = year + Math.floor(nextMonthIndex / 12);
-  const normalizedMonthIndex = ((nextMonthIndex % 12) + 12) % 12;
-  const targetDay = Math.min(day, getDaysInMonth(targetYear, normalizedMonthIndex));
-
-  return new Date(
-    Date.UTC(
-      targetYear,
-      normalizedMonthIndex,
-      targetDay,
-      date.getUTCHours(),
-      date.getUTCMinutes(),
-      date.getUTCSeconds(),
-      date.getUTCMilliseconds()
-    )
-  );
-}
-
-export function getNextBackupDueAt(
-  cadence: BackupCadence,
-  lastBackupAt: Date | null
-): Date | null {
-  if (!lastBackupAt) return null;
-
-  if (cadence === "DAILY") {
-    return new Date(lastBackupAt.getTime() + 24 * 60 * 60 * 1000);
-  }
-
-  if (cadence === "WEEKLY") {
-    return new Date(lastBackupAt.getTime() + 7 * 24 * 60 * 60 * 1000);
-  }
-
-  return addMonthsClamped(lastBackupAt, 1);
-}
-
-export function isBackupDue(
-  cadence: BackupCadence,
-  lastBackupAt: Date | null,
-  now = new Date()
-): boolean {
-  if (!lastBackupAt) return true;
-
-  const nextDueAt = getNextBackupDueAt(cadence, lastBackupAt);
-  return nextDueAt !== null && now >= nextDueAt;
-}

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

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

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

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

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