tenseleyflow/shithub / b94d92c

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package web

+

+import (

+	"embed"

+	"io/fs"

+)

+

+//go:embed all:templates

+var templatesFS embed.FS

+

+//go:embed all:static

+var staticFS embed.FS

+

+// TemplatesFS returns the read-only filesystem rooted at the templates dir.

+func TemplatesFS() fs.FS {

+	sub, err := fs.Sub(templatesFS, "templates")

+	if err != nil {

+		// embed.FS layout is verified at compile time; this can't fail at

+		// runtime once the build succeeds.

+		panic(err)

+	}

+	return sub

+}

+

+// StaticFS returns the read-only filesystem rooted at the static dir.

+func StaticFS() fs.FS {

+	sub, err := fs.Sub(staticFS, "static")

+	if err != nil {

+		panic(err)

+	}

+	return sub

+}

+

+// LogoSVG returns the canonical mascot SVG bytes (full mark, with tentacles

+// and pitchfork).

+func LogoSVG() ([]byte, error) {

+	return staticFS.ReadFile("static/logo/shithub.svg")

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+// Package handlers registers HTTP handlers on the web server's mux.

+//

+// S00 ships only the hello page, static asset server, and health endpoints.

+// Each future sprint adds its own routes via this package.

+package handlers

+

+import (

+	"fmt"

+	"io/fs"

+	"log/slog"

+	"net/http"

+

+	"github.com/tenseleyFlow/shithub/internal/web/render"

+)

+

+// Deps holds the dependencies the handlers need. The web package owns the

+// embedded filesystems and constructs Deps; this package stays decoupled

+// from the embed.FS instances so it remains testable.

+type Deps struct {

+	Logger      *slog.Logger

+	TemplatesFS fs.FS

+	StaticFS    fs.FS

+	LogoSVG     string

+}

+

+// Register wires every S00 route into mux. Later sprints' Register entrypoints

+// are called from here; for S00 the surface is small.

+func Register(mux *http.ServeMux, deps Deps) error {

+	if deps.Logger == nil {

+		return fmt.Errorf("handlers.Register: nil Logger")

+	}

+	if deps.TemplatesFS == nil {

+		return fmt.Errorf("handlers.Register: nil TemplatesFS")

+	}

+	if deps.StaticFS == nil {

+		return fmt.Errorf("handlers.Register: nil StaticFS")

+	}

+

+	r, err := render.New(deps.TemplatesFS)

+	if err != nil {

+		return fmt.Errorf("renderer: %w", err)

+	}

+

+	mux.Handle("GET /static/", http.StripPrefix("/static/", staticFileServer(deps.StaticFS)))

+	mux.HandleFunc("GET /healthz", healthz)

+	mux.HandleFunc("GET /readyz", readyz)

+	mux.Handle("GET /{$}", helloHandler{render: r, logoSVG: deps.LogoSVG, logger: deps.Logger})

+

+	return nil

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package handlers

+

+import (

+	"io"

+	"log/slog"

+	"net/http"

+	"net/http/httptest"

+	"strings"

+	"testing"

+)

+

+func TestHandlers(t *testing.T) {

+	t.Parallel()

+

+	mux := http.NewServeMux()

+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))

+	if err := Register(mux, Deps{

+		Logger:      logger,

+		TemplatesFS: testTemplatesFS(t),

+		StaticFS:    testStaticFS(t),

+		LogoSVG:     `<svg xmlns="http://www.w3.org/2000/svg"><title>shithub</title></svg>`,

+	}); err != nil {

+		t.Fatalf("Register: %v", err)

+	}

+

+	tests := []struct {

+		name        string

+		path        string

+		wantStatus  int

+		wantBodyAny []string

+		wantHeader  map[string]string

+	}{

+		{

+			name:        "hello page",

+			path:        "/",

+			wantStatus:  http.StatusOK,

+			wantBodyAny: []string{"shithub", "GitHub. Open source. Without Copilot.", "Sprint 00"},

+			wantHeader:  map[string]string{"Content-Type": "text/html; charset=utf-8"},

+		},

+		{

+			name:        "healthz",

+			path:        "/healthz",

+			wantStatus:  http.StatusOK,

+			wantBodyAny: []string{"ok"},

+		},

+		{

+			name:        "readyz",

+			path:        "/readyz",

+			wantStatus:  http.StatusOK,

+			wantBodyAny: []string{"ready"},

+		},

+		{

+			name:        "logo svg",

+			path:        "/static/logo/shithub.svg",

+			wantStatus:  http.StatusOK,

+			wantBodyAny: []string{"<svg", "shithub"},

+		},

+		{

+			name:       "unknown route 404",

+			path:       "/this-path-does-not-exist",

+			wantStatus: http.StatusNotFound,

+		},

+	}

+

+	for _, tc := range tests {

+		t.Run(tc.name, func(t *testing.T) {

+			t.Parallel()

+

+			req := httptest.NewRequest(http.MethodGet, tc.path, nil)

+			rec := httptest.NewRecorder()

+			mux.ServeHTTP(rec, req)

+

+			if rec.Code != tc.wantStatus {

+				t.Fatalf("status: got %d, want %d (body=%q)", rec.Code, tc.wantStatus, rec.Body.String())

+			}

+			body := rec.Body.String()

+			for _, want := range tc.wantBodyAny {

+				if !strings.Contains(body, want) {

+					t.Errorf("body missing %q\nbody=%q", want, body)

+				}

+			}

+			for k, want := range tc.wantHeader {

+				if got := rec.Header().Get(k); got != want {

+					t.Errorf("header %s: got %q, want %q", k, got, want)

+				}

+			}

+		})

+	}

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package handlers

+

+import "net/http"

+

+// healthz returns 200 if the process is alive. No dependency checks.

+func healthz(w http.ResponseWriter, _ *http.Request) {

+	w.Header().Set("Content-Type", "text/plain; charset=utf-8")

+	w.Header().Set("Cache-Control", "no-store")

+	_, _ = w.Write([]byte("ok\n"))

+}

+

+// readyz returns 200 when the server is ready to take traffic. S00 has no

+// dependencies to check; S01 wires Postgres into here, S04 wires storage.

+func readyz(w http.ResponseWriter, _ *http.Request) {

+	w.Header().Set("Content-Type", "text/plain; charset=utf-8")

+	w.Header().Set("Cache-Control", "no-store")

+	_, _ = w.Write([]byte("ready\n"))

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package handlers

+

+import (

+	"html/template"

+	"log/slog"

+	"net/http"

+

+	"github.com/tenseleyFlow/shithub/internal/version"

+	"github.com/tenseleyFlow/shithub/internal/web/render"

+)

+

+type helloHandler struct {

+	render  *render.Renderer

+	logoSVG string

+	logger  *slog.Logger

+}

+

+type helloData struct {

+	Title   string

+	Version string

+	Commit  string

+	BuiltAt string

+	LogoSVG template.HTML

+}

+

+func (h helloHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {

+	data := helloData{

+		Title:   "Welcome",

+		Version: version.Version,

+		Commit:  version.Commit,

+		BuiltAt: version.BuiltAt,

+		LogoSVG: template.HTML(h.logoSVG), // #nosec G203 — embedded server-owned asset

+	}

+	w.Header().Set("Content-Type", "text/html; charset=utf-8")

+	if err := h.render.Render(w, "hello", data); err != nil {

+		h.logger.Error("render hello", "error", err)

+		http.Error(w, "internal server error", http.StatusInternalServerError)

+	}

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package handlers

+

+import (

+	"io/fs"

+	"net/http"

+)

+

+// staticFileServer serves files from the embedded static FS with sane

+// caching headers. S02 will replace this with a content-hashed asset

+// pipeline; S00 keeps the surface minimal.

+func staticFileServer(staticFS fs.FS) http.Handler {

+	fileServer := http.FileServer(http.FS(staticFS))

+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

+		// Conservative caching: short TTL + must-revalidate. Long-cache

+		// behavior moves to fingerprinted URLs in S02.

+		w.Header().Set("Cache-Control", "public, max-age=300, must-revalidate")

+		fileServer.ServeHTTP(w, r)

+	})

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package handlers

+

+import (

+	"io/fs"

+	"testing"

+	"testing/fstest"

+)

+

+// testTemplatesFS returns a minimal in-memory templates filesystem matching

+// the layout the production embed produces (after Sub-rooting).

+func testTemplatesFS(t *testing.T) fs.FS {

+	t.Helper()

+	return fstest.MapFS{

+		"_layout.html": &fstest.MapFile{

+			Data: []byte(`{{ define "layout" }}<!DOCTYPE html><html><head><title>{{ .Title }} · shithub</title></head><body>{{ template "page" . }}</body></html>{{ end }}`),

+		},

+		"hello.html": &fstest.MapFile{

+			Data: []byte(`{{ define "page" }}<main>shithub - GitHub. Open source. Without Copilot. Sprint 00 v{{ .Version }}</main>{{ end }}`),

+		},

+	}

+}

+

+// testStaticFS returns a minimal in-memory static filesystem matching the

+// layout the production embed produces.

+func testStaticFS(t *testing.T) fs.FS {

+	t.Helper()

+	return fstest.MapFS{

+		"logo/shithub.svg": &fstest.MapFile{

+			Data: []byte(`<svg xmlns="http://www.w3.org/2000/svg"><title>shithub</title></svg>`),

+		},

+		"css/shithub.css": &fstest.MapFile{

+			Data: []byte(`body { color: black; }`),

+		},

+	}

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+// Package render owns the html/template loading and rendering pipeline.

+// S02 will broaden this with helpers (relativeTime, urlFor, octicon, etc.);

+// S00 ships only what the hello page needs.

+package render

+

+import (

+	"bytes"

+	"fmt"

+	"html/template"

+	"io"

+	"io/fs"

+	"path"

+	"strings"

+)

+

+// Renderer holds parsed templates indexed by page name.

+type Renderer struct {

+	pages map[string]*template.Template

+}

+

+// New parses every page template under tmplFS. A "page template" is any file

+// at the root of tmplFS that does NOT begin with an underscore. Files that

+// begin with an underscore (e.g. "_layout.html") are partials, parsed once

+// into every page.

+func New(tmplFS fs.FS) (*Renderer, error) {

+	entries, err := fs.ReadDir(tmplFS, ".")

+	if err != nil {

+		return nil, fmt.Errorf("read template root: %w", err)

+	}

+

+	var (

+		partialNames []string

+		pageNames    []string

+	)

+	for _, e := range entries {

+		if e.IsDir() {

+			continue

+		}

+		name := e.Name()

+		if !strings.HasSuffix(name, ".html") {

+			continue

+		}

+		if strings.HasPrefix(name, "_") {

+			partialNames = append(partialNames, name)

+		} else {

+			pageNames = append(pageNames, name)

+		}

+	}

+

+	r := &Renderer{pages: make(map[string]*template.Template, len(pageNames))}

+	for _, page := range pageNames {

+		t := template.New(page).Funcs(funcMap())

+		all := append([]string{}, partialNames...)

+		all = append(all, page)

+		// Convert to filesystem paths.

+		for i := range all {

+			all[i] = path.Clean(all[i])

+		}

+		parsed, err := t.ParseFS(tmplFS, all...)

+		if err != nil {

+			return nil, fmt.Errorf("parse %s: %w", page, err)

+		}

+		r.pages[strings.TrimSuffix(page, ".html")] = parsed

+	}

+	return r, nil

+}

+

+// Render writes the named page to w using data as the template root context.

+// The page's templates execute the layout via {{ template "layout" . }}.

+func (r *Renderer) Render(w io.Writer, name string, data any) error {

+	t, ok := r.pages[name]

+	if !ok {

+		return fmt.Errorf("render: unknown page %q", name)

+	}

+	// Pages declare a "page" block; the layout calls into it.

+	var buf bytes.Buffer

+	if err := t.ExecuteTemplate(&buf, "layout", data); err != nil {

+		return fmt.Errorf("execute %s: %w", name, err)

+	}

+	_, err := w.Write(buf.Bytes())

+	return err

+}

+

+func funcMap() template.FuncMap {

+	return template.FuncMap{

+		// safeHTML embeds trusted HTML directly. Callers MUST ensure the

+		// input is server-controlled — never user input. S25's markdown

+		// pipeline supplies the canonical helper for user content.

+		"safeHTML": func(s string) template.HTML {

+			return template.HTML(s) // #nosec G203 — trusted-input only

+		},

+	}

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+// Package web boots the shithub HTTP server. S00 stands up only the bare

+// shell — the hello page, static assets, and /healthz. S02 (web shell)

+// fleshes out the middleware stack, sessions, error pages, and Primer-themed

+// base templates. Every later sprint adds routes via internal/web/handlers.

+package web

+

+import (

+	"context"

+	"errors"

+	"fmt"

+	"log/slog"

+	"net/http"

+	"os"

+	"os/signal"

+	"syscall"

+	"time"

+

+	"github.com/tenseleyFlow/shithub/internal/web/handlers"

+)

+

+// Options configures the web server.

+type Options struct {

+	Addr string

+}

+

+// Run boots the web server and blocks until shutdown.

+//

+// It listens for SIGINT/SIGTERM and gracefully drains in-flight requests on

+// exit. The S00 surface is intentionally minimal; later sprints add the full

+// middleware stack, session store, and rendering pipeline.

+func Run(ctx context.Context, opts Options) error {

+	if opts.Addr == "" {

+		opts.Addr = ":8080"

+	}

+

+	logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{

+		Level: slog.LevelInfo,

+	}))

+

+	logoBytes, err := LogoSVG()

+	if err != nil {

+		return fmt.Errorf("load logo: %w", err)

+	}

+

+	mux := http.NewServeMux()

+	if err := handlers.Register(mux, handlers.Deps{

+		Logger:      logger,

+		TemplatesFS: TemplatesFS(),

+		StaticFS:    StaticFS(),

+		LogoSVG:     string(logoBytes),

+	}); err != nil {

+		return fmt.Errorf("register handlers: %w", err)

+	}

+

+	srv := &http.Server{

+		Addr:              opts.Addr,

+		Handler:           mux,

+		ReadHeaderTimeout: 10 * time.Second,

+		ReadTimeout:       30 * time.Second,

+		WriteTimeout:      30 * time.Second,

+		IdleTimeout:       120 * time.Second,

+	}

+

+	errCh := make(chan error, 1)

+	go func() {

+		logger.Info("shithub web server starting", "addr", opts.Addr)

+		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {

+			errCh <- err

+		}

+		close(errCh)

+	}()

+

+	sigCh := make(chan os.Signal, 1)

+	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)

+	defer signal.Stop(sigCh)

+

+	select {

+	case err, ok := <-errCh:

+		if !ok {

+			return nil

+		}

+		return err

+	case sig := <-sigCh:

+		logger.Info("shutdown signal received", "signal", sig.String())

+	case <-ctx.Done():

+		logger.Info("context canceled, shutting down")

+	}

+

+	shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)

+	defer cancel()

+	if err := srv.Shutdown(shutdownCtx); err != nil {

+		return fmt.Errorf("shutdown: %w", err)

+	}

+	return nil

+}

+/* SPDX-License-Identifier: AGPL-3.0-or-later */

+/*

+ * shithub — base styles.

+ *

+ * S00 ships a tiny stylesheet sufficient for the hello page across light /

+ * dark / auto / high-contrast themes. S02 introduces the full theme system

+ * via Primer primitives; this file becomes one layer in a stack.

+ *

+ * Color tokens follow Primer's naming so the migration in S02 is mechanical.

+ */

+

+:root {

+  --canvas-default: #ffffff;

+  --canvas-subtle: #f6f8fa;

+  --fg-default: #1f2328;

+  --fg-muted: #59636e;

+  --border-default: #d0d7de;

+  --accent-fg: #0969da;

+  --danger-fg: #cf222e;

+  --shithub-mark: var(--danger-fg);

+}

+

+[data-theme="dark"] {

+  --canvas-default: #0d1117;

+  --canvas-subtle: #161b22;

+  --fg-default: #f0f6fc;

+  --fg-muted: #9198a1;

+  --border-default: #3d444d;

+  --accent-fg: #4493f8;

+  --danger-fg: #f85149;

+}

+

+[data-theme="high-contrast"] {

+  --canvas-default: #000000;

+  --canvas-subtle: #0a0c10;

+  --fg-default: #ffffff;

+  --fg-muted: #d9dee3;

+  --border-default: #7a828e;

+  --accent-fg: #71b7ff;

+  --danger-fg: #ff6a69;

+}

+

+* {

+  box-sizing: border-box;

+}

+

+html, body {

+  margin: 0;

+  padding: 0;

+  background: var(--canvas-default);

+  color: var(--fg-default);

+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Noto Sans", Helvetica, Arial, sans-serif;

+  font-size: 16px;

+  line-height: 1.5;

+}

+

+a {

+  color: var(--accent-fg);

+  text-decoration: none;

+}

+a:hover { text-decoration: underline; }

+

+.hello {

+  max-width: 640px;

+  margin: 4rem auto;

+  padding: 2rem 1.5rem;

+  text-align: center;

+}

+

+.hello-logo {

+  margin: 0 auto 1.5rem;

+  width: 160px;

+  height: 160px;

+  color: var(--shithub-mark);

+}

+

+.hello-logo svg {

+  width: 100%;

+  height: 100%;

+}

+

+.hello-title {

+  font-size: 2.75rem;

+  margin: 0 0 0.5rem;

+  letter-spacing: -0.02em;

+}

+

+.hello-tagline {

+  color: var(--fg-muted);

+  font-size: 1.15rem;

+  margin: 0 0 2rem;

+}

+

+.hello-meta {

+  display: grid;

+  grid-template-columns: max-content 1fr;

+  gap: 0.25rem 1rem;

+  max-width: 24rem;

+  margin: 0 auto 2rem;

+  padding: 1rem 1.5rem;

+  background: var(--canvas-subtle);

+  border: 1px solid var(--border-default);

+  border-radius: 6px;

+  text-align: left;

+  font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace;

+  font-size: 0.875rem;

+}

+

+.hello-meta dt {

+  color: var(--fg-muted);

+}

+

+.hello-meta dd {

+  margin: 0;

+}

+

+.hello-status {

+  color: var(--fg-muted);

+  margin: 0 auto 2rem;

+  max-width: 36rem;

+}

+

+.hello-links {

+  display: flex;

+  justify-content: center;

+  gap: 1rem;

+  font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace;

+  font-size: 0.875rem;

+}

+{{ define "layout" -}}

+<!DOCTYPE html>

+<html lang="en" data-theme="auto">

+<head>

+  <script>

+    // Theme flash avoidance: read cookie or system preference and apply

+    // before any CSS computes. Establishes the dark/light/auto/high-contrast

+    // contract S02 will broaden.

+    (function () {

+      var match = document.cookie.match(/(?:^|; )theme=([^;]+)/);

+      var theme = match ? decodeURIComponent(match[1]) : "auto";

+      if (theme === "auto") {

+        theme = matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";

+      }

+      document.documentElement.setAttribute("data-theme", theme);

+    })();

+  </script>

+  <meta charset="UTF-8">

+  <meta name="viewport" content="width=device-width, initial-scale=1">

+  <meta name="color-scheme" content="light dark">

+  <meta name="description" content="shithub — GitHub. Open source. Without Copilot.">

+  <title>{{ .Title }} · shithub</title>

+  <link rel="icon" type="image/svg+xml" href="/static/logo/favicon.svg">

+  <link rel="stylesheet" href="/static/css/shithub.css">

+  <link rel="stylesheet" href="/static/primer/primer.css" onerror="this.remove()">

+</head>

+<body>

+{{ template "page" . }}

+</body>

+</html>

+{{- end }}

+{{ define "page" -}}

+<main class="hello">

+  <div class="hello-logo" aria-hidden="true">

+    {{ .LogoSVG }}

+  </div>

+  <h1 class="hello-title">shithub</h1>

+  <p class="hello-tagline">GitHub. Open source. Without Copilot.</p>

+

+  <dl class="hello-meta">

+    <dt>Version</dt><dd>{{ .Version }}</dd>

+    <dt>Commit</dt><dd>{{ .Commit }}</dd>

+    <dt>Built</dt><dd>{{ .BuiltAt }}</dd>

+  </dl>

+

+  <p class="hello-status">

+    Pre-launch. Sprint 00 — project scaffolding — is shipping. Every later

+    sprint adds real product surface; see the planning index for the full

+    roadmap.

+  </p>

+

+  <nav class="hello-links" aria-label="Project links">

+    <a href="/healthz">/healthz</a>

+    <a href="/readyz">/readyz</a>

+  </nav>

+</main>

+{{- end }}