@peaske7/readit 0.1.8 → 0.2.1

package/go/internal/server/server.go

@@ -0,0 +1,453 @@
+package server
+
+import (
+	"encoding/json"
+	"fmt"
+	"html/template"
+	"io/fs"
+	"log"
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+// Options configures the server.
+type Options struct {
+	Files      []FileEntry
+	Port       int
+	Host       string
+	Clean      bool
+	AssetsDir  string
+	Dev        bool
+	OnShutdown func()
+}
+
+type FileEntry struct {
+	FilePath string
+	Content  []byte
+}
+
+type Server struct {
+	mux        *http.ServeMux
+	files      map[string]*FileState
+	fileOrder  []string
+	sse        *SSEBroker
+	watcher    *Watcher
+	renderer   *Renderer
+	settings   Settings
+	workingDir string
+	clean      bool
+	assetsFS   fs.FS
+	tmpl       *template.Template
+	isDev      bool
+	viteProxy  http.Handler
+	mu         sync.RWMutex
+
+	commentCache   map[string]*resolvedCacheEntry
+	commentCacheMu sync.RWMutex
+
+	commentFileMu    sync.Mutex
+	commentFileLocks map[string]*sync.Mutex
+
+	httpServer *http.Server
+}
+
+type resolvedCacheEntry struct {
+	commentMtimeMs int64
+	sourceHash     string
+	comments       []Comment
+}
+
+func NewServer(opts Options) (*Server, error) {
+	wd, err := os.Getwd()
+	if err != nil {
+		wd = "."
+	}
+
+	s := &Server{
+		mux:              http.NewServeMux(),
+		files:            make(map[string]*FileState),
+		renderer:         NewRenderer(),
+		settings:         DefaultSettings(),
+		workingDir:       wd,
+		clean:            opts.Clean,
+		tmpl:             CompileTemplate(),
+		isDev:            opts.Dev,
+		commentCache:     make(map[string]*resolvedCacheEntry),
+		commentFileLocks: make(map[string]*sync.Mutex),
+	}
+
+	if loaded, err := ReadSettings(); err == nil {
+		s.settings = loaded
+	}
+
+	s.sse = NewSSEBroker(opts.Dev, opts.OnShutdown)
+
+	w, err := NewWatcher(func(path string) {
+		s.onFileChange(path)
+	})
+	if err != nil {
+		return nil, fmt.Errorf("watcher: %w", err)
+	}
+	s.watcher = w
+
+	if opts.AssetsDir != "" {
+		s.assetsFS = os.DirFS(opts.AssetsDir)
+	} else if !opts.Dev {
+		s.assetsFS = EmbeddedAssetsFS()
+	}
+
+	if opts.Dev {
+		viteURL, _ := url.Parse("http://127.0.0.1:24678")
+		s.viteProxy = httputil.NewSingleHostReverseProxy(viteURL)
+	}
+
+	for _, f := range opts.Files {
+		if err := s.loadFile(f); err != nil {
+			log.Printf("Warning: failed to load %s: %v", f.FilePath, err)
+		}
+	}
+
+	s.registerRoutes()
+
+	return s, nil
+}
+
+func (s *Server) registerRoutes() {
+	s.mux.HandleFunc("GET /api/documents", s.listDocuments)
+	s.mux.HandleFunc("POST /api/documents", s.addDocument)
+	s.mux.HandleFunc("GET /api/document", s.getDocument)
+
+	s.mux.HandleFunc("GET /api/comments/raw", s.rawComments)
+	s.mux.HandleFunc("GET /api/comments", s.listComments)
+	s.mux.HandleFunc("POST /api/comments", s.createComment)
+	s.mux.HandleFunc("PUT /api/comments/{id}/reanchor", s.reanchorComment)
+	s.mux.HandleFunc("PUT /api/comments/{id}", s.updateComment)
+	s.mux.HandleFunc("DELETE /api/comments/{id}", s.deleteComment)
+	s.mux.HandleFunc("DELETE /api/comments", s.deleteAllComments)
+
+	s.mux.HandleFunc("GET /api/settings", s.getSettings)
+	s.mux.HandleFunc("PUT /api/settings", s.updateSettings)
+
+	s.mux.HandleFunc("GET /api/document/stream", s.sse.DocumentStream)
+	s.mux.HandleFunc("GET /api/heartbeat", s.sse.Heartbeat)
+
+	s.mux.HandleFunc("GET /api/health", func(w http.ResponseWriter, r *http.Request) {
+		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+	})
+
+	s.mux.HandleFunc("GET /{$}", s.servePage)
+
+	if s.assetsFS != nil {
+		s.mux.Handle("GET /assets/", http.FileServer(http.FS(s.assetsFS)))
+	}
+
+	if s.isDev && s.viteProxy != nil {
+		s.mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
+			s.viteProxy.ServeHTTP(w, r)
+		})
+	}
+}
+
+func (s *Server) Start(host string, port int) (int, error) {
+	for p := port; p <= 65535; p++ {
+		addr := fmt.Sprintf("%s:%d", host, p)
+		ln, err := net.Listen("tcp", addr)
+		if err != nil {
+			if p < 65535 {
+				log.Printf("Port %d is busy, trying %d...", p, p+1)
+				continue
+			}
+			return 0, fmt.Errorf("no available port found")
+		}
+
+		s.httpServer = &http.Server{Handler: s.mux}
+		log.Printf("Server listening on http://%s", addr)
+
+		go func() {
+			if err := s.httpServer.Serve(ln); err != nil && err != http.ErrServerClosed {
+				log.Printf("HTTP server error: %v", err)
+			}
+		}()
+
+		return p, nil
+	}
+	return 0, fmt.Errorf("no available port")
+}
+
+func (s *Server) Stop() {
+	if s.httpServer != nil {
+		_ = s.httpServer.Close()
+	}
+	s.watcher.Close()
+}
+
+func (s *Server) loadFile(f FileEntry) error {
+	absPath, err := filepath.Abs(f.FilePath)
+	if err != nil {
+		return err
+	}
+	absPath, err = filepath.EvalSymlinks(absPath)
+	if err != nil {
+		return err
+	}
+
+	content := f.Content
+	if content == nil {
+		data, err := os.ReadFile(absPath)
+		if err != nil {
+			return err
+		}
+		content = data
+	}
+
+	result, err := s.renderer.Render(content)
+	if err != nil {
+		return err
+	}
+
+	s.mu.Lock()
+	_, alreadyExists := s.files[absPath]
+	s.files[absPath] = &FileState{
+		FilePath:     absPath,
+		FileName:     filepath.Base(absPath),
+		Content:      content,
+		RenderedHTML: result.HTML,
+		Headings:     result.Headings,
+		IsLoaded:     true,
+	}
+	if !alreadyExists {
+		s.fileOrder = append(s.fileOrder, absPath)
+	}
+	s.mu.Unlock()
+
+	if err := s.watcher.Add(absPath); err != nil {
+		log.Printf("Warning: failed to watch %s: %v", absPath, err)
+	}
+	return nil
+}
+
+func (s *Server) onFileChange(path string) {
+	s.mu.RLock()
+	_, ok := s.files[path]
+	s.mu.RUnlock()
+	if !ok {
+		return
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return
+	}
+	result, err := s.renderer.Render(data)
+	if err != nil {
+		return
+	}
+
+	s.mu.Lock()
+	state, ok := s.files[path]
+	if ok {
+		state.Content = data
+		state.RenderedHTML = result.HTML
+		state.Headings = result.Headings
+	}
+	s.mu.Unlock()
+
+	if !ok {
+		return
+	}
+
+	s.invalidateCommentCache(path)
+
+	jsonEvent, _ := json.Marshal(map[string]string{
+		"type": "document-updated",
+		"path": path,
+	})
+	s.sse.Broadcast(string(jsonEvent))
+}
+
+func (s *Server) invalidateCommentCache(path string) {
+	s.commentCacheMu.Lock()
+	delete(s.commentCache, path)
+	s.commentCacheMu.Unlock()
+}
+
+func (s *Server) defaultFilePath() string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	if len(s.fileOrder) > 0 {
+		return s.fileOrder[0]
+	}
+	return ""
+}
+
+func (s *Server) resolveFilePath(r *http.Request) string {
+	if p := r.URL.Query().Get("path"); p != "" {
+		if abs, err := filepath.Abs(p); err == nil {
+			if resolved, err := filepath.EvalSymlinks(abs); err == nil {
+				return resolved
+			}
+		}
+		return p
+	}
+	return s.defaultFilePath()
+}
+
+func (s *Server) getFileState(path string) *FileState {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.files[path]
+}
+
+func (s *Server) servePage(w http.ResponseWriter, r *http.Request) {
+	s.mu.RLock()
+	var defaultPath string
+	if len(s.fileOrder) > 0 {
+		defaultPath = s.fileOrder[0]
+	}
+	state := s.files[defaultPath]
+
+	if state == nil {
+		s.mu.RUnlock()
+		http.Error(w, "no document loaded", http.StatusNotFound)
+		return
+	}
+
+	// Collect file data under the read lock, but resolve comments after releasing it
+	type fileSnapshot struct {
+		path         string
+		content      []byte
+		renderedHTML string
+		headings     []Heading
+	}
+	snapshots := make([]fileSnapshot, 0, len(s.files))
+	for path, fs := range s.files {
+		snapshots = append(snapshots, fileSnapshot{
+			path:         path,
+			content:      fs.Content,
+			renderedHTML: fs.RenderedHTML,
+			headings:     fs.Headings,
+		})
+	}
+
+	files := make([]FileRef, 0, len(s.fileOrder))
+	for _, p := range s.fileOrder {
+		if f, ok := s.files[p]; ok {
+			files = append(files, FileRef{Path: p, FileName: f.FileName})
+		}
+	}
+
+	stateFileName := state.FileName
+	stateRenderedHTML := state.RenderedHTML
+	clean := s.clean
+	workingDir := s.workingDir
+	settings := s.settings
+	s.mu.RUnlock()
+
+	// Resolve comments outside the main lock to avoid nested locking
+	docs := make(map[string]InlineDocData)
+	for _, snap := range snapshots {
+		comments := s.resolveCommentsFor(snap.path, &FileState{
+			Content:      snap.content,
+			RenderedHTML: snap.renderedHTML,
+		})
+		docs[snap.path] = InlineDocData{
+			Headings: snap.headings,
+			Comments: comments,
+		}
+	}
+
+	inline := InlineData{
+		Files:      files,
+		ActiveFile: defaultPath,
+		Clean:      clean,
+		WorkingDir: workingDir,
+		Documents:  docs,
+		Settings:   settings,
+	}
+
+	inlineJSON, err := SafeJSONStringify(inline)
+	if err != nil {
+		http.Error(w, "failed to serialize data", http.StatusInternalServerError)
+		return
+	}
+
+	jsPath, cssPath := s.resolveAssetPaths()
+
+	proseClass := "prose-serif"
+	if settings.FontFamily == FontSansSerif {
+		proseClass = "prose-sans"
+	}
+
+	var viteClient template.HTML
+	if s.isDev {
+		viteClient = `<script type="module" src="http://127.0.0.1:24678/@vite/client"></script>`
+	}
+
+	data := TemplateData{
+		Title:        stateFileName,
+		CSSPath:      cssPath,
+		JSPath:       jsPath,
+		DocumentHTML: template.HTML(stateRenderedHTML),
+		InlineJSON:   inlineJSON,
+		IsDev:        s.isDev,
+		FontFamily:   settings.FontFamily,
+		ProseClass:   proseClass,
+		ViteClient:   viteClient,
+	}
+
+	page, err := RenderPage(s.tmpl, data)
+	if err != nil {
+		http.Error(w, "template error", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	_, _ = w.Write([]byte(page))
+}
+
+func (s *Server) resolveAssetPaths() (jsPath, cssPath string) {
+	if s.isDev {
+		return "http://127.0.0.1:24678/src/main.ts", ""
+	}
+
+	if s.assetsFS != nil {
+		data, err := fs.ReadFile(s.assetsFS, ".vite/manifest.json")
+		if err == nil {
+			var manifest map[string]struct {
+				File string   `json:"file"`
+				CSS  []string `json:"css"`
+			}
+			if json.Unmarshal(data, &manifest) == nil {
+				if entry, ok := manifest["index.html"]; ok {
+					jsPath = "/" + entry.File
+					if len(entry.CSS) > 0 {
+						cssPath = "/" + entry.CSS[0]
+					}
+					return
+				}
+			}
+		}
+	}
+
+	return "/assets/index.js", ""
+}
+
+func writeJSON(w http.ResponseWriter, status int, data any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(data)
+}
+
+func writeError(w http.ResponseWriter, status int, msg string) {
+	writeJSON(w, status, map[string]string{"error": msg})
+}
+
+func readJSON(r *http.Request, v any) error {
+	defer func() { _ = r.Body.Close() }()
+	return json.NewDecoder(r.Body).Decode(v)
+}

package/go/internal/server/server_bench_test.go

@@ -0,0 +1,122 @@
+package server
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func setupBenchServer(b *testing.B, lines int) (*Server, string) {
+	b.Helper()
+
+	// Generate markdown content
+	var sb strings.Builder
+	sb.WriteString("# Benchmark Document\n\n")
+	for i := range lines {
+		switch i % 10 {
+		case 0:
+			fmt.Fprintf(&sb, "## Section %d\n\n", i/10)
+		case 5:
+			sb.WriteString("```go\nfunc hello() {\n\tfmt.Println(\"world\")\n}\n```\n\n")
+		default:
+			fmt.Fprintf(&sb, "Paragraph %d with **bold** and *italic* text and `code`.\n\n", i)
+		}
+	}
+
+	// Write to temp file
+	tmpDir := b.TempDir()
+	filePath := filepath.Join(tmpDir, "bench.md")
+	if err := os.WriteFile(filePath, []byte(sb.String()), 0644); err != nil {
+		b.Fatal(err)
+	}
+
+	srv, err := NewServer(Options{
+		Files: []FileEntry{{FilePath: filePath}},
+		Port:  0,
+		Host:  "127.0.0.1",
+	})
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	return srv, filePath
+}
+
+// BenchmarkSSRPage measures the full SSR page render (TTFB equivalent).
+func BenchmarkSSRPage1000Lines(b *testing.B) {
+	srv, _ := setupBenchServer(b, 1000)
+	defer srv.watcher.Close()
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		req := httptest.NewRequest("GET", "/", nil)
+		w := httptest.NewRecorder()
+		srv.mux.ServeHTTP(w, req)
+		if w.Code != http.StatusOK {
+			b.Fatalf("unexpected status %d", w.Code)
+		}
+	}
+}
+
+func BenchmarkSSRPage3000Lines(b *testing.B) {
+	srv, _ := setupBenchServer(b, 3000)
+	defer srv.watcher.Close()
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		req := httptest.NewRequest("GET", "/", nil)
+		w := httptest.NewRecorder()
+		srv.mux.ServeHTTP(w, req)
+		if w.Code != http.StatusOK {
+			b.Fatalf("unexpected status %d", w.Code)
+		}
+	}
+}
+
+// BenchmarkGetDocument measures the /api/document JSON response.
+func BenchmarkGetDocument1000Lines(b *testing.B) {
+	srv, filePath := setupBenchServer(b, 1000)
+	defer srv.watcher.Close()
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		req := httptest.NewRequest("GET", "/api/document?path="+filePath, nil)
+		w := httptest.NewRecorder()
+		srv.mux.ServeHTTP(w, req)
+		if w.Code != http.StatusOK {
+			b.Fatalf("unexpected status %d", w.Code)
+		}
+	}
+}
+
+// BenchmarkStartup measures cold server creation (init + first render).
+func BenchmarkServerStartup1000Lines(b *testing.B) {
+	var sb strings.Builder
+	sb.WriteString("# Benchmark Document\n\n")
+	for i := range 1000 {
+		fmt.Fprintf(&sb, "Paragraph %d with **bold** text.\n\n", i)
+	}
+
+	tmpDir := b.TempDir()
+	filePath := filepath.Join(tmpDir, "bench.md")
+	if err := os.WriteFile(filePath, []byte(sb.String()), 0644); err != nil {
+		b.Fatal(err)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		srv, err := NewServer(Options{
+			Files: []FileEntry{{FilePath: filePath}},
+			Port:  0,
+			Host:  "127.0.0.1",
+		})
+		if err != nil {
+			b.Fatal(err)
+		}
+		srv.watcher.Close()
+	}
+}

package/go/internal/server/settings.go

@@ -0,0 +1,110 @@
+package server
+
+import (
+	"encoding/json"
+	"net/http"
+	"os"
+	"path/filepath"
+)
+
+func DefaultSettings() Settings {
+	return Settings{
+		Version:    1,
+		FontFamily: FontSerif,
+	}
+}
+
+func settingsPath() string {
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		return ".readit/settings.json"
+	}
+	return filepath.Join(home, ".readit", "settings.json")
+}
+
+func ReadSettings() (Settings, error) {
+	data, err := os.ReadFile(settingsPath())
+	if err != nil {
+		return DefaultSettings(), err
+	}
+	s := DefaultSettings()
+	if err := json.Unmarshal(data, &s); err != nil {
+		return DefaultSettings(), err
+	}
+	return s, nil
+}
+
+func WriteSettings(s Settings) error {
+	path := settingsPath()
+	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+		return err
+	}
+	data, err := json.MarshalIndent(s, "", "  ")
+	if err != nil {
+		return err
+	}
+	tmp := path + ".tmp"
+	if err := os.WriteFile(tmp, data, 0644); err != nil {
+		return err
+	}
+	return os.Rename(tmp, path)
+}
+
+func (s *Server) getSettings(w http.ResponseWriter, r *http.Request) {
+	s.mu.RLock()
+	settings := s.settings
+	s.mu.RUnlock()
+	writeJSON(w, http.StatusOK, settings)
+}
+
+func (s *Server) updateSettings(w http.ResponseWriter, r *http.Request) {
+	var body struct {
+		FontFamily  string       `json:"fontFamily"`
+		Keybindings []Keybinding `json:"keybindings"`
+	}
+	if err := readJSON(r, &body); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+
+	if body.FontFamily != "" {
+		if body.FontFamily != FontSerif && body.FontFamily != FontSansSerif {
+			writeError(w, http.StatusBadRequest, "fontFamily must be 'serif' or 'sans-serif'")
+			return
+		}
+	}
+
+	// Validate keybinding overrides
+	for _, kb := range body.Keybindings {
+		if kb.ID == "" {
+			writeError(w, http.StatusBadRequest, "keybinding id is required")
+			return
+		}
+		if kb.Binding != nil && kb.Binding.Key == "" {
+			writeError(w, http.StatusBadRequest, "keybinding key is required when binding is provided")
+			return
+		}
+	}
+
+	// Build new settings under write lock for atomicity
+	s.mu.Lock()
+	newSettings := s.settings
+
+	if body.FontFamily != "" {
+		newSettings.FontFamily = body.FontFamily
+	}
+	if body.Keybindings != nil {
+		newSettings.Keybindings = body.Keybindings
+	}
+
+	if err := WriteSettings(newSettings); err != nil {
+		s.mu.Unlock()
+		writeError(w, http.StatusInternalServerError, "failed to save settings")
+		return
+	}
+
+	s.settings = newSettings
+	s.mu.Unlock()
+
+	writeJSON(w, http.StatusOK, newSettings)
+}