@peaske7/readit 0.1.7 → 0.2.0

package/src/{server/index.ts → server.ts}

@@ -3,7 +3,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { basename, dirname, join } from "node:path";
-import { findAnchorWithFallback } from "../lib/anchor.js";
+import { findAnchorWithFallback } from "./lib/anchor.js";
 import {
   computeHash,
   createComment,
@@ -12,20 +12,15 @@ import {
   parseCommentFile,
   serializeComments,
   truncateSelection,
-} from "../lib/comment-storage.js";
-import { getFileType } from "../lib/utils.js";
+} from "./lib/comment-storage.js";
+import { isMarkdownFile } from "./lib/utils.js";
 import {
   AnchorConfidences,
   type Comment,
   type DocumentSettings,
-  type DocumentType,
-  type EditorScheme,
-  EditorSchemes,
   FontFamilies,
   type FontFamily,
-} from "../types/index.js";
-
-// ─── Helpers ─────────────────────────────────────────────────────────
+} from "./schema.js";
 
 function isErrnoException(err: unknown): err is NodeJS.ErrnoException {
   return err instanceof Error && "code" in err;
@@ -33,7 +28,6 @@ function isErrnoException(err: unknown): err is NodeJS.ErrnoException {
 
 export interface FileEntry {
   content?: string;
-  type: DocumentType;
   filePath: string;
 }
 
@@ -194,12 +188,6 @@ function isValidFontFamily(value: unknown): value is FontFamily {
   return value === FontFamilies.SERIF || value === FontFamilies.SANS_SERIF;
 }
 
-function isValidEditorScheme(value: unknown): value is EditorScheme {
-  return Object.values(EditorSchemes).includes(value as EditorScheme);
-}
-
-// ─── PID file helpers ───────────────────────────────────────────────
-
 export const SERVER_INFO_PATH = path.join(
   os.homedir(),
   ".readit",
@@ -225,8 +213,6 @@ export async function removeServerInfo(): Promise<void> {
   }
 }
 
-// ─── Response helpers ───────────────────────────────────────────────
-
 function json(data: unknown, status = 200): Response {
   return Response.json(data, { status });
 }
@@ -235,15 +221,11 @@ function errorResponse(message: string, status: number): Response {
   return Response.json({ error: message }, { status });
 }
 
-// ─── Route context ──────────────────────────────────────────────────
-
 interface RouteContext {
   filePath: string;
   getCurrentContent: () => Promise<string>;
 }
 
-// ─── Route handlers ─────────────────────────────────────────────────
-
 async function getComments(ctx: RouteContext): Promise<Response> {
   try {
     const currentContent = await ctx.getCurrentContent();
@@ -446,22 +428,16 @@ async function getSettingsRoute(): Promise<Response> {
 async function updateSettingsRoute(req: Request): Promise<Response> {
   try {
     const body = await req.json();
-    const { fontFamily, editorScheme, keybindings } = body;
+    const { fontFamily } = body;
 
     if (fontFamily !== undefined && !isValidFontFamily(fontFamily)) {
       return errorResponse("Invalid font family", 400);
     }
 
-    if (editorScheme !== undefined && !isValidEditorScheme(editorScheme)) {
-      return errorResponse("Invalid editor scheme", 400);
-    }
-
     const current = await readSettings();
     const settings: DocumentSettings = {
       ...current,
       ...(fontFamily !== undefined && { fontFamily }),
-      ...(editorScheme !== undefined && { editorScheme }),
-      ...(keybindings !== undefined && { keybindings }),
     };
 
     await writeSettings(settings);
@@ -472,8 +448,6 @@ async function updateSettingsRoute(req: Request): Promise<Response> {
   }
 }
 
-// ─── SSE helpers ────────────────────────────────────────────────────
-
 function createDocumentStream(
   sseClients: Set<ReadableStreamDefaultController>,
 ): Response {
@@ -509,27 +483,30 @@ function createDocumentStream(
   });
 }
 
-function createHeartbeat(isDev: boolean): Response {
+function createHeartbeat(
+  onOpen: (controller: ReadableStreamDefaultController) => void,
+  onClose: (controller: ReadableStreamDefaultController) => void,
+): Response {
   let interval: ReturnType<typeof setInterval>;
+  let captured: ReadableStreamDefaultController;
 
   const stream = new ReadableStream({
     start(controller) {
+      captured = controller;
       controller.enqueue("data: connected\n\n");
+      onOpen(controller);
       interval = setInterval(() => {
         try {
           controller.enqueue("data: ping\n\n");
         } catch {
           clearInterval(interval);
+          onClose(controller);
         }
       }, 5000);
     },
     cancel() {
       clearInterval(interval);
-      if (isDev) return;
-      setTimeout(() => {
-        console.log("\nBrowser disconnected, shutting down...");
-        process.exit(0);
-      }, 100);
+      onClose(captured);
     },
   });
 
@@ -542,8 +519,6 @@ function createHeartbeat(isDev: boolean): Response {
   });
 }
 
-// ─── Static file serving ────────────────────────────────────────────
-
 async function serveStaticFile(
   distPath: string,
   pathname: string,
@@ -564,40 +539,85 @@ async function serveStaticFile(
   return new Response("Not Found", { status: 404 });
 }
 
-// ─── Extract route param ────────────────────────────────────────────
+const VITE_DEV_PORT = 24678;
+const VITE_DEV_ORIGIN = `http://127.0.0.1:${VITE_DEV_PORT}`;
+
+async function proxyToVite(
+  req: Request,
+  pathname: string,
+  search: string,
+): Promise<Response> {
+  const target = `${VITE_DEV_ORIGIN}${pathname}${search}`;
+  try {
+    return await fetch(
+      new Request(target, {
+        method: req.method,
+        headers: req.headers,
+        body: req.body,
+        redirect: "manual",
+      }),
+    );
+  } catch {
+    return new Response("Vite dev server not available", { status: 502 });
+  }
+}
+
+async function isViteReady(): Promise<boolean> {
+  try {
+    const res = await fetch(`${VITE_DEV_ORIGIN}/`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function spawnViteDev(): Promise<() => void> {
+  // If Vite is already running (e.g. after bun --watch restart), reuse it
+  if (await isViteReady()) {
+    return () => {};
+  }
+
+  const child = Bun.spawn(
+    ["bunx", "vite", "--port", String(VITE_DEV_PORT), "--strictPort"],
+    { stdout: "ignore", stderr: "inherit" },
+  );
+
+  const maxWaitMs = 10_000;
+  const start = Date.now();
+  while (Date.now() - start < maxWaitMs) {
+    if (await isViteReady()) break;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+
+  return () => {
+    child.kill();
+  };
+}
 
 function extractCommentId(pathname: string): string | undefined {
   const match = pathname.match(/^\/api\/comments\/([^/]+)/);
   return match?.[1];
 }
 
-// ─── Multi-file state ───────────────────────────────────────────────
-
 interface FileState {
   content: string | null;
   isLoaded: boolean;
-  type: DocumentType;
   debounceTimer: ReturnType<typeof setTimeout> | null;
 }
 
-// ─── Server creation ────────────────────────────────────────────────
-
 interface ServerWithWatchers {
   server: ReturnType<typeof Bun.serve>;
   watchers: FSWatcher[];
 }
 
 function createServer(options: ServerOptions): ServerWithWatchers {
-  // Map of absolute path → mutable file state
   const fileMap = new Map<string, FileState>();
-  // Ordered list of file paths (insertion order for tab display)
   const fileOrder: string[] = [];
 
   for (const entry of options.files) {
     fileMap.set(entry.filePath, {
       content: entry.content ?? null,
       isLoaded: entry.content !== undefined,
-      type: entry.type,
       debounceTimer: null,
     });
     fileOrder.push(entry.filePath);
@@ -605,6 +625,8 @@ function createServer(options: ServerOptions): ServerWithWatchers {
 
   const defaultPath = fileOrder[0];
   const sseClients = new Set<ReadableStreamDefaultController>();
+  const heartbeatClients = new Set<ReadableStreamDefaultController>();
+  let shutdownTimer: ReturnType<typeof setTimeout> | null = null;
 
   function sendEvent(event: unknown): void {
     const message = `data: ${JSON.stringify(event)}\n\n`;
@@ -617,6 +639,31 @@ function createServer(options: ServerOptions): ServerWithWatchers {
     }
   }
 
+  function clearShutdownTimer(): void {
+    if (!shutdownTimer) return;
+    clearTimeout(shutdownTimer);
+    shutdownTimer = null;
+  }
+
+  function onHeartbeatOpen(controller: ReadableStreamDefaultController): void {
+    heartbeatClients.add(controller);
+    clearShutdownTimer();
+  }
+
+  function onHeartbeatClose(controller: ReadableStreamDefaultController): void {
+    heartbeatClients.delete(controller);
+    if (isDev || heartbeatClients.size > 0 || shutdownTimer) return;
+
+    shutdownTimer = setTimeout(() => {
+      if (heartbeatClients.size > 0) {
+        clearShutdownTimer();
+        return;
+      }
+      console.log("\nBrowser disconnected, shutting down...");
+      process.exit(0);
+    }, 1500);
+  }
+
   async function ensureFileContent(filePath: string): Promise<string> {
     const state = fileMap.get(filePath);
     if (!state) {
@@ -633,7 +680,6 @@ function createServer(options: ServerOptions): ServerWithWatchers {
     return content;
   }
 
-  // Resolve the target file from ?path= query param, falling back to first file
   function resolveContext(url: URL): RouteContext | null {
     const requestedPath = url.searchParams.get("path") ?? defaultPath;
     const state = fileMap.get(requestedPath);
@@ -696,18 +742,11 @@ function createServer(options: ServerOptions): ServerWithWatchers {
       const { pathname } = url;
       const method = req.method;
 
-      // ── API routes ──────────────────────────────────────────
-
-      // Document list (multi-file)
       if (pathname === "/api/documents" && method === "GET") {
-        const files = fileOrder.map((fp) => {
-          const state = fileMap.get(fp)!;
-          return {
-            path: fp,
-            fileName: basename(fp),
-            type: state.type,
-          };
-        });
+        const files = fileOrder.map((fp) => ({
+          path: fp,
+          fileName: basename(fp),
+        }));
         return json({
           files,
           clean: options.clean || false,
@@ -715,7 +754,6 @@ function createServer(options: ServerOptions): ServerWithWatchers {
         });
       }
 
-      // Register a document for this session without forcing focus
       if (pathname === "/api/documents" && method === "POST") {
         try {
           const { path: requestedPath } = await req.json();
@@ -733,11 +771,9 @@ function createServer(options: ServerOptions): ServerWithWatchers {
             }
             throw err;
           }
-          const fileType = getFileType(filePath);
-
-          if (!fileType) {
+          if (!isMarkdownFile(filePath)) {
             return errorResponse(
-              `Unsupported file type: ${filePath} (expected .md, .markdown, .html, or .htm)`,
+              `Unsupported file type: ${filePath} (expected .md or .markdown)`,
               400,
             );
           }
@@ -748,15 +784,12 @@ function createServer(options: ServerOptions): ServerWithWatchers {
             return json({
               path: filePath,
               fileName: basename(filePath),
-              type: fileType,
               status: "present",
             });
           } else {
-            // New document — register metadata only, load content on demand
             fileMap.set(filePath, {
               content: null,
               isLoaded: false,
-              type: fileType,
               debounceTimer: null,
             });
             fileOrder.push(filePath);
@@ -768,14 +801,12 @@ function createServer(options: ServerOptions): ServerWithWatchers {
               type: "document-added",
               path: filePath,
               fileName: basename(filePath),
-              fileType,
             });
           }
 
           return json({
             path: filePath,
             fileName: basename(filePath),
-            type: fileType,
             status: "added",
           });
         } catch (err) {
@@ -784,15 +815,12 @@ function createServer(options: ServerOptions): ServerWithWatchers {
         }
       }
 
-      // Single document (backward compat + path-aware)
       if (pathname === "/api/document" && method === "GET") {
         const ctxOrRes = requireContext(url);
         if (ctxOrRes instanceof Response) return ctxOrRes;
-        const state = fileMap.get(ctxOrRes.filePath)!;
         const content = await ctxOrRes.getCurrentContent();
         return json({
           content,
-          type: state.type,
           filePath: ctxOrRes.filePath,
           fileName: basename(ctxOrRes.filePath),
           clean: options.clean || false,
@@ -808,10 +836,9 @@ function createServer(options: ServerOptions): ServerWithWatchers {
       }
 
       if (pathname === "/api/heartbeat" && method === "GET") {
-        return createHeartbeat(isDev);
+        return createHeartbeat(onHeartbeatOpen, onHeartbeatClose);
       }
 
-      // Comments routes
       if (pathname === "/api/comments" && method === "GET") {
         const ctxOrRes = requireContext(url);
         if (ctxOrRes instanceof Response) return ctxOrRes;
@@ -836,7 +863,6 @@ function createServer(options: ServerOptions): ServerWithWatchers {
         return clearComments(ctxOrRes);
       }
 
-      // Parameterized comment routes
       const commentId = extractCommentId(pathname);
       if (commentId) {
         const ctxOrRes = requireContext(url);
@@ -853,7 +879,6 @@ function createServer(options: ServerOptions): ServerWithWatchers {
         }
       }
 
-      // Settings routes (global, not per-document)
       if (pathname === "/api/settings" && method === "GET") {
         return getSettingsRoute();
       }
@@ -862,8 +887,9 @@ function createServer(options: ServerOptions): ServerWithWatchers {
         return updateSettingsRoute(req);
       }
 
-      // ── Static / SPA serving ────────────────────────────────
-
+      if (isDev) {
+        return proxyToVite(req, pathname, url.search);
+      }
       return serveStaticFile(distPath, pathname);
     },
   });
@@ -879,8 +905,6 @@ function createServer(options: ServerOptions): ServerWithWatchers {
   return { server, watchers };
 }
 
-// ─── Port fallback + start ──────────────────────────────────────────
-
 export async function startServer(
   options: ServerOptions,
 ): Promise<ServerResult> {
@@ -893,9 +917,15 @@ export async function startServer(
       const displayHost =
         options.host === "0.0.0.0" ? "localhost" : options.host;
 
+      let stopVite: (() => void) | undefined;
+      if (process.env.NODE_ENV === "development") {
+        stopVite = await spawnViteDev();
+      }
+
       const originalStop = server.stop.bind(server);
       const wrappedServer = {
         stop() {
+          stopVite?.();
           for (const w of watchers) w.close();
           originalStop();
         },

package/src/{store/index.ts → store.ts}

@@ -1,7 +1,5 @@
 import { createStore, useStore } from "zustand";
-import type { Comment, Document, Selection } from "../types";
-
-// ─── Types ───────────────────────────────────────────────────────────
+import type { Comment, Document, Selection } from "./schema";
 
 export interface DocumentState {
   document: Document;
@@ -11,41 +9,27 @@ export interface DocumentState {
   selection: Selection | null;
   pendingSelectionTop: number | undefined;
   pendingCommentText: string;
-  highlightPositions: Record<string, number>;
-  documentPositions: Record<string, number>;
   scrollY: number;
-  hoveredCommentId: string | undefined;
   reanchorTarget: { commentId: string } | null;
 }
 
 export interface AppStore {
-  // Multi-document state
   documents: Map<string, DocumentState>;
   activeDocumentPath: string | null;
   documentOrder: string[];
   workingDirectory: string | null;
 
-  // Global actions
   setWorkingDirectory: (dir: string) => void;
   openDocument: (doc: Document, opts?: { active?: boolean }) => void;
   closeDocument: (filePath: string) => void;
   setActiveDocument: (filePath: string) => void;
 
-  // Per-document setters (default to active doc)
+  // Setters default to active doc when filePath omitted
   setComments: (comments: Comment[], filePath?: string) => void;
   setCommentsError: (error: string | null, filePath?: string) => void;
   setSelection: (selection: Selection | null, filePath?: string) => void;
   setPendingSelectionTop: (top: number | undefined, filePath?: string) => void;
-  setHighlightPositions: (
-    positions: Record<string, number>,
-    filePath?: string,
-  ) => void;
-  setDocumentPositions: (
-    positions: Record<string, number>,
-    filePath?: string,
-  ) => void;
   setScrollY: (y: number, filePath?: string) => void;
-  setHoveredCommentId: (id: string | undefined, filePath?: string) => void;
   setReanchorTarget: (
     target: { commentId: string } | null,
     filePath?: string,
@@ -53,12 +37,9 @@ export interface AppStore {
   setPendingCommentText: (text: string, filePath?: string) => void;
   updateDocumentContent: (content: string, filePath?: string) => void;
 
-  // Helpers
   getActiveDocumentState: () => DocumentState | undefined;
 }
 
-// ─── Helpers ─────────────────────────────────────────────────────────
-
 function createInitialDocumentState(doc: Document): DocumentState {
   return {
     document: doc,
@@ -68,10 +49,7 @@ function createInitialDocumentState(doc: Document): DocumentState {
     selection: null,
     pendingSelectionTop: undefined,
     pendingCommentText: "",
-    highlightPositions: {},
-    documentPositions: {},
     scrollY: 0,
-    hoveredCommentId: undefined,
     reanchorTarget: null,
   };
 }
@@ -80,8 +58,6 @@ function sortComments(comments: Comment[]): Comment[] {
   return [...comments].sort((a, b) => a.startOffset - b.startOffset);
 }
 
-// ─── Store Factory ───────────────────────────────────────────────────
-
 export function createAppStore() {
   return createStore<AppStore>((set, get) => {
     const resolveFilePath = (filePath?: string): string | null =>
@@ -192,30 +168,12 @@ export function createAppStore() {
         updateDocState(path, () => ({ pendingSelectionTop: top }));
       },
 
-      setHighlightPositions: (positions, filePath?) => {
-        const path = resolveFilePath(filePath);
-        if (!path) return;
-        updateDocState(path, () => ({ highlightPositions: positions }));
-      },
-
-      setDocumentPositions: (positions, filePath?) => {
-        const path = resolveFilePath(filePath);
-        if (!path) return;
-        updateDocState(path, () => ({ documentPositions: positions }));
-      },
-
       setScrollY: (y, filePath?) => {
         const path = resolveFilePath(filePath);
         if (!path) return;
         updateDocState(path, () => ({ scrollY: y }));
       },
 
-      setHoveredCommentId: (id, filePath?) => {
-        const path = resolveFilePath(filePath);
-        if (!path) return;
-        updateDocState(path, () => ({ hoveredCommentId: id }));
-      },
-
       setReanchorTarget: (target, filePath?) => {
         const path = resolveFilePath(filePath);
         if (!path) return;
@@ -245,10 +203,20 @@ export function createAppStore() {
   });
 }
 
-// ─── Singleton + React Hook ─────────────────────────────────────────
-
 export const appStore = createAppStore();
 
 export function useAppStore<T>(selector: (state: AppStore) => T): T {
   return useStore(appStore, selector);
 }
+
+interface UIState {
+  hoveredCommentId: string | undefined;
+}
+
+export const uiStore = createStore<UIState>(() => ({
+  hoveredCommentId: undefined,
+}));
+
+export function useUI<T>(selector: (s: UIState) => T): T {
+  return useStore(uiStore, selector);
+}

package/vite.config.ts

@@ -5,6 +5,14 @@ import { defineConfig } from "vite";
 export default defineConfig({
   plugins: [tailwindcss(), react()],
   server: {
+    port: 24678,
+    strictPort: true,
+    host: "127.0.0.1",
+    hmr: {
+      host: "127.0.0.1",
+      port: 24678,
+      clientPort: 24678,
+    },
     proxy: {
       "/api": {
         target: "http://localhost:4567",