main.go

//go:build !explore
package main

import (
	"embed"
	"flag"
	"fmt"
	"io"
	"io/fs"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"strings"

	"bolt-viewer/pkg/api"
	"bolt-viewer/pkg/db"
)

//go:embed all:web/dist
var webDist embed.FS

func serveIndexHTML(w http.ResponseWriter, r *http.Request, distFS fs.FS) {
	f, err := distFS.Open("index.html")
	if err != nil {
		http.NotFound(w, r)
		return
	}
	defer f.Close()
	data, err := io.ReadAll(f)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	w.Write(data)
}

func main() {
	var dbPath string
	var port int
	var writeMode bool
	flag.StringVar(&dbPath, "db", "", "path to trivy Bolt DB file (required)")
	flag.StringVar(&dbPath, "d", "", "path to trivy Bolt DB (shorthand)")
	flag.IntVar(&port, "port", 8050, "port to listen on")
	flag.IntVar(&port, "p", 8050, "port (shorthand)")
	flag.BoolVar(&writeMode, "write", false, "open DB in write mode (default: read-only)")
	flag.BoolVar(&writeMode, "w", false, "write mode (shorthand)")
	flag.Parse()

	if dbPath == "" {
		fmt.Fprintln(os.Stderr, "error: -d/--db is required")
		flag.Usage()
		os.Exit(1)
	}
	absPath, err := filepath.Abs(dbPath)
	if err != nil {
		log.Fatalf("invalid db path: %v", err)
	}
	if _, err := os.Stat(absPath); err != nil {
		log.Fatalf("db file not found: %v", err)
	}

	readOnly := !writeMode
	store, err := db.Open(absPath, readOnly)
	if err != nil {
		log.Fatalf("failed to open database: %v", err)
	}
	defer store.Close()

	h := &api.Handlers{Store: store, WriteMode: writeMode}
	apiHandler := api.Routes(h)

	// Serve static frontend from embedded dist
	distFS, err := fs.Sub(webDist, "web/dist")
	if err != nil {
		log.Printf("warning: web/dist not found, API only mode: %v", err)
	}
	var handler http.Handler = apiHandler
	if err == nil {
		fileServer := http.FileServer(http.FS(distFS))
		handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if strings.HasPrefix(r.URL.Path, "/api/") {
				apiHandler.ServeHTTP(w, r)
				return
			}
			path := strings.TrimPrefix(r.URL.Path, "/")
			if path == "" || path == "index.html" {
				// Serve index.html directly to avoid FileServer 301 redirect on root
				serveIndexHTML(w, r, distFS)
				return
			}
			if _, err := distFS.Open(path); err != nil {
				// SPA fallback: serve index.html for client-side routes
				serveIndexHTML(w, r, distFS)
				return
			}
			r.URL.Path = "/" + path
			fileServer.ServeHTTP(w, r)
		})
	}

	addr := fmt.Sprintf(":%d", port)
	log.Printf("bolt-viewer listening on %s (db=%s, readOnly=%v)", addr, absPath, readOnly)
	if err := http.ListenAndServe(addr, handler); err != nil {
		log.Fatal(err)
	}
}