Files
agent-evals/backend/internal/server/server.go
Evan Reichard 2a9e793971 feat: implement WYSIWYG markdown editor with Go backend and React frontend
Implements full markdown editor application with:

Backend (Go):
- Cobra CLI with --data-dir, --port, --host flags
- REST API for CRUD operations on markdown files
- File storage on disk with flat structure
- Logrus logging for all operations
- Static asset serving for frontend
- Comprehensive tests for CRUD and static assets

Frontend (React + TypeScript + Tailwind):
- Markdown editor with live GFM preview
- File management UI (list, create, open, save, delete)
- Theme system (Dark, Light, System) with persistence
- Responsive design (320px to 1920px)
- Component tests for core functionality

Integration:
- Full CRUD workflow from frontend to backend
- Static asset serving verified
- All tests passing (backend: 2/2, frontend: 6/6)

Files added:
- Backend: API handler, logger, server, tests
- Frontend: Components, tests, config files
- Build artifacts: compiled backend binary and frontend dist
- Documentation: README and implementation summary
2026-02-06 21:09:35 -05:00

70 lines
1.4 KiB
Go

package server
import (
"context"
"fmt"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"github.com/gorilla/mux"
"github.com/sirupsen/logrus"
)
type Server struct {
host string
port int
handler http.Handler
log *logrus.Logger
}
func NewServer(host string, port int, handler http.Handler, log *logrus.Logger) *Server {
return &Server{
host: host,
port: port,
handler: handler,
log: log,
}
}
func (s *Server) Start() error {
router := mux.NewRouter()
router.Handle("/api/{filename:.+.md}", s.handler)
router.PathPrefix("/").Handler(http.FileServer(http.Dir("frontend/dist")))
srv := &http.Server{
Addr: fmt.Sprintf("%s:%d", s.host, s.port),
Handler: router,
}
// Start server
go func() {
s.log.Infof("Server listening on %s:%d", s.host, s.port)
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
s.log.Errorf("Server error: %v", err)
}
}()
// Wait for interrupt signal
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
s.log.Info("Shutting down server...")
// Create context with timeout
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
// Shutdown server
if err := srv.Shutdown(ctx); err != nil {
s.log.Errorf("Server shutdown error: %v", err)
return err
}
s.log.Info("Server stopped")
return nil
}