Add bootstrap flow for hosted web loads

Author: julianknutsen

internal/api/handlers.go

@@ -190,6 +190,35 @@ func (s *Server) handleDashboard(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, toDashboardResponse(data))
 }
 
+func (s *Server) handleBootstrap(w http.ResponseWriter, r *http.Request) {
+	ctx, span := apiTracer.Start(r.Context(), "api.bootstrap")
+	defer span.End()
+	r = r.WithContext(ctx)
+
+	var client *sdk.Client
+	resolved, err := s.clientFunc(r)
+	if err == nil {
+		client = resolved
+	} else if s.publicClient != nil {
+		client = s.publicClient
+	}
+
+	resp := BootstrapResponse{
+		Hosted: s.hosted,
+	}
+	if client != nil {
+		resp.Connected = true
+		resp.RigHandle = client.RigHandle()
+		resp.Mode = client.Mode()
+	}
+	if upstream := r.Header.Get("X-Wasteland"); upstream != "" {
+		resp.ActiveUpstream = upstream
+	}
+
+	w.Header().Set("Cache-Control", "no-store")
+	writeJSON(w, http.StatusOK, resp)
+}
+
 func (s *Server) handleLeaderboard(w http.ResponseWriter, r *http.Request) {
 	client, ok := s.resolveClient(w, r)
 	if !ok {

internal/api/infrastructure_test.go

@@ -117,6 +117,45 @@ func TestNewHostedWorkspace_ConfigIncludesWorkspaceAndActiveUpstream(t *testing.
 	}
 }
 
+func TestBootstrap_ReturnsRigHandleAndNoStore(t *testing.T) {
+	srv := New(newTestClient(newFakeDB()))
+	ts := httptest.NewServer(srv)
+	defer ts.Close()
+
+	req, err := http.NewRequest(http.MethodGet, ts.URL+"/api/bootstrap", nil)
+	if err != nil {
+		t.Fatalf("new request: %v", err)
+	}
+	req.Header.Set("X-Wasteland", "stale/upstream")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("GET /api/bootstrap: %v", err)
+	}
+	defer resp.Body.Close() //nolint:errcheck // test cleanup
+
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("status = %d, want %d", resp.StatusCode, http.StatusOK)
+	}
+	if got := resp.Header.Get("Cache-Control"); got != "no-store" {
+		t.Fatalf("Cache-Control = %q, want %q", got, "no-store")
+	}
+
+	var boot BootstrapResponse
+	if err := json.NewDecoder(resp.Body).Decode(&boot); err != nil {
+		t.Fatalf("decode bootstrap: %v", err)
+	}
+	if boot.RigHandle != "alice" {
+		t.Fatalf("rig_handle = %q, want %q", boot.RigHandle, "alice")
+	}
+	if !boot.Connected {
+		t.Fatalf("expected connected bootstrap response")
+	}
+	if boot.ActiveUpstream != "stale/upstream" {
+		t.Fatalf("active_upstream = %q, want %q", boot.ActiveUpstream, "stale/upstream")
+	}
+}
+
 func TestSetProfileQuerier_OverridesProfileSource(t *testing.T) {
 	sheetJSON := `{"identity":{"display_name":"Injected"},"value_dimensions":{"quality":0.7}}`
 	pq := &fakePileQuerier{rows: map[string][]map[string]any{

internal/api/routes.go

@@ -3,6 +3,7 @@ package api
 // registerRoutes wires all API endpoints onto the server mux.
 func (s *Server) registerRoutes() {
 	// Read endpoints.
+	s.mux.HandleFunc("GET /api/bootstrap", s.handleBootstrap)
 	s.mux.HandleFunc("GET /api/wanted", s.handleBrowse)
 	s.mux.HandleFunc("GET /api/wanted/{id}", s.handleDetail)
 	s.mux.HandleFunc("GET /api/dashboard", s.handleDashboard)

internal/api/types.go

@@ -129,6 +129,15 @@ type UpstreamInfoJSON struct {
 	Mode     string `json:"mode"`
 }
 
+// WastelandConfigJSON is the JSON representation of a hosted joined wasteland.
+type WastelandConfigJSON struct {
+	Upstream string `json:"upstream"`
+	ForkOrg  string `json:"fork_org"`
+	ForkDB   string `json:"fork_db"`
+	Mode     string `json:"mode"`
+	Signing  bool   `json:"signing"`
+}
+
 // ConfigResponse is the JSON response for GET /api/config.
 type ConfigResponse struct {
 	RigHandle string             `json:"rig_handle"`
@@ -139,6 +148,18 @@ type ConfigResponse struct {
 	Upstreams []UpstreamInfoJSON `json:"upstreams,omitempty"`
 }
 
+// BootstrapResponse is the JSON response for GET /api/bootstrap.
+type BootstrapResponse struct {
+	Authenticated  bool                  `json:"authenticated"`
+	Connected      bool                  `json:"connected"`
+	Hosted         bool                  `json:"hosted,omitempty"`
+	RigHandle      string                `json:"rig_handle,omitempty"`
+	Wastelands     []WastelandConfigJSON `json:"wastelands,omitempty"`
+	Environment    string                `json:"environment,omitempty"`
+	ActiveUpstream string                `json:"active_upstream,omitempty"`
+	Mode           string                `json:"mode,omitempty"`
+}
+
 // LeaderboardEntryJSON is the JSON representation of a leaderboard entry.
 type LeaderboardEntryJSON struct {
 	RigHandle     string   `json:"rig_handle"`

internal/hosted/auth.go

@@ -113,11 +113,14 @@ func (s *Server) AuthMiddleware(next http.Handler) http.Handler {
 		upstream := r.Header.Get("X-Wasteland")
 		upstreams := workspace.Upstreams()
 
-		if upstream == "" && len(upstreams) > 0 && r.Method == http.MethodGet {
-			// Default to first upstream for reads when header is missing
-			// (race with frontend context init, impersonation, or
-			// single-wasteland backward compat).
-			upstream = upstreams[0].Upstream
+		if upstream == "" && r.Method == http.MethodGet {
+			if remembered := s.sessions.ActiveUpstream(sessionID); remembered != "" {
+				upstream = remembered
+			} else if len(upstreams) > 0 {
+				// Default to the first upstream for backward compatibility when
+				// bootstrap has not established an explicit choice yet.
+				upstream = upstreams[0].Upstream
+			}
 		}
 
 		if upstream == "" {
@@ -136,6 +139,7 @@ func (s *Server) AuthMiddleware(next http.Handler) http.Handler {
 			passOrBlock(w, r, http.StatusBadRequest, "unknown upstream: "+upstream)
 			return
 		}
+		s.sessions.RememberActiveUpstream(sessionID, upstream)
 
 		// Staging-only impersonation: X-Impersonate header overrides rig handle
 		// for read-only requests so operators can see the UI as another user.

internal/hosted/auth_test.go

@@ -7,6 +7,8 @@ import (
 	"net/http/httptest"
 	"strings"
 	"testing"
+
+	"github.com/gastownhall/wasteland/internal/api"
 )
 
 const testSecret = "test-session-secret"
@@ -83,6 +85,7 @@ func setupHostedTestServer(t *testing.T) (*SessionStore, *httptest.Server) {
 	mux := http.NewServeMux()
 	mux.HandleFunc("POST /api/auth/connect", server.handleConnect)
 	mux.HandleFunc("GET /api/auth/status", server.handleAuthStatus)
+	mux.HandleFunc("GET /api/bootstrap", server.handleBootstrap)
 	mux.HandleFunc("POST /api/auth/logout", server.handleLogout)
 	mux.HandleFunc("POST /api/auth/connect-session", server.handleConnectSession)
 	mux.HandleFunc("POST /api/auth/join", server.handleJoin)
@@ -148,6 +151,7 @@ func setupMultiWastelandTestServer(t *testing.T) (*SessionStore, *httptest.Serve
 	})
 
 	mux := http.NewServeMux()
+	mux.HandleFunc("GET /api/bootstrap", server.handleBootstrap)
 	mux.Handle("/", server.AuthMiddleware(inner))
 
 	ts := httptest.NewServer(mux)
@@ -486,6 +490,72 @@ func TestHandleAuthStatus_Authenticated(t *testing.T) {
 	}
 }
 
+func TestHandleBootstrap_Authenticated_RemembersAndReturnsActiveUpstream(t *testing.T) {
+	sessions, ts := setupMultiWastelandTestServer(t)
+
+	sessionID, _ := sessions.Create("conn-1")
+	req, _ := http.NewRequest("GET", ts.URL+"/api/bootstrap", nil)
+	req.Header.Set("X-Wasteland", "gastownhall/gascity")
+	req.AddCookie(&http.Cookie{
+		Name:  cookieName,
+		Value: SignSessionCookie(sessionID, "conn-1", testSecret),
+	})
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close() //nolint:errcheck // test cleanup
+
+	if got := resp.Header.Get("Cache-Control"); got != "no-store" {
+		t.Fatalf("Cache-Control = %q, want %q", got, "no-store")
+	}
+
+	var boot api.BootstrapResponse
+	if err := json.NewDecoder(resp.Body).Decode(&boot); err != nil {
+		t.Fatalf("decode bootstrap: %v", err)
+	}
+	if !boot.Authenticated || !boot.Connected {
+		t.Fatalf("expected authenticated connected bootstrap, got %+v", boot)
+	}
+	if boot.ActiveUpstream != "gastownhall/gascity" {
+		t.Fatalf("active_upstream = %q, want %q", boot.ActiveUpstream, "gastownhall/gascity")
+	}
+	if boot.Mode != "pr" {
+		t.Fatalf("mode = %q, want %q", boot.Mode, "pr")
+	}
+	if got := sessions.ActiveUpstream(sessionID); got != "gastownhall/gascity" {
+		t.Fatalf("remembered upstream = %q, want %q", got, "gastownhall/gascity")
+	}
+}
+
+func TestHandleBootstrap_UsesRememberedUpstreamWhenHeaderMissing(t *testing.T) {
+	sessions, ts := setupMultiWastelandTestServer(t)
+
+	sessionID, _ := sessions.Create("conn-1")
+	sessions.RememberActiveUpstream(sessionID, "gastownhall/gascity")
+
+	req, _ := http.NewRequest("GET", ts.URL+"/api/bootstrap", nil)
+	req.AddCookie(&http.Cookie{
+		Name:  cookieName,
+		Value: SignSessionCookie(sessionID, "conn-1", testSecret),
+	})
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close() //nolint:errcheck // test cleanup
+
+	var boot api.BootstrapResponse
+	if err := json.NewDecoder(resp.Body).Decode(&boot); err != nil {
+		t.Fatalf("decode bootstrap: %v", err)
+	}
+	if boot.ActiveUpstream != "gastownhall/gascity" {
+		t.Fatalf("active_upstream = %q, want %q", boot.ActiveUpstream, "gastownhall/gascity")
+	}
+}
+
 func TestHandleLogout(t *testing.T) {
 	sessions, ts := setupHostedTestServer(t)
 

internal/hosted/resolver.go

@@ -144,6 +144,28 @@ func (wr *WorkspaceResolver) ResolveContext(ctx context.Context, session *UserSe
 	return wr.waitOnResolveResult(ctx, span, resultCh)
 }
 
+// WarmSession primes the workspace cache using metadata already fetched on the
+// boot path. It shares the same singleflight key as live resolves.
+func (wr *WorkspaceResolver) WarmSession(session *UserSession, apiKey string, meta *UserMetadata) {
+	if session == nil || session.ConnectionID == "" || meta == nil || len(meta.Wastelands) == 0 {
+		return
+	}
+	go func() {
+		ctx, cancel := ctxutil.Detached(context.Background(), resolveMissTimeout)
+		defer cancel()
+		if _, ok := wr.cachedWorkspace(session.ConnectionID); ok {
+			return
+		}
+		resultCh := wr.group.DoChan(session.ConnectionID, func() (any, error) {
+			return wr.resolveFromMetadata(ctx, session.ConnectionID, apiKey, meta)
+		})
+		select {
+		case <-resultCh:
+		case <-ctx.Done():
+		}
+	}()
+}
+
 func (wr *WorkspaceResolver) waitOnResolveResult(ctx context.Context, span trace.Span, resultCh <-chan singleflight.Result) (*sdk.Workspace, error) {
 	_, waitSpan := hostedTracer.Start(ctx, "hosted.workspace.wait_for_resolve")
 	defer waitSpan.End()
@@ -182,16 +204,25 @@ func (wr *WorkspaceResolver) resolveMiss(ctx context.Context, session *UserSessi
 		resolveSpan.RecordError(err)
 		return nil, fmt.Errorf("resolving credentials: %w", err)
 	}
+	workspace, err := wr.resolveFromMetadata(resolveCtx, session.ConnectionID, apiKey, meta)
+	if err != nil {
+		resolveSpan.RecordError(err)
+		return nil, err
+	}
+	resolveSpan.SetAttributes(attribute.Int("wasteland.count", len(meta.Wastelands)))
+	return workspace, nil
+}
+
+func (wr *WorkspaceResolver) resolveFromMetadata(_ context.Context, connectionID, apiKey string, meta *UserMetadata) (*sdk.Workspace, error) {
 	if meta == nil || len(meta.Wastelands) == 0 {
-		return nil, fmt.Errorf("no wasteland config found for connection %s", session.ConnectionID)
+		return nil, fmt.Errorf("no wasteland config found for connection %s", connectionID)
 	}
 
 	ws := sdk.NewWorkspace(meta.RigHandle)
 	for i := range meta.Wastelands {
 		wl := &meta.Wastelands[i]
-		client, err := wr.buildClient(wl, meta.RigHandle, session.ConnectionID, apiKey, meta)
+		client, err := wr.buildClient(wl, meta.RigHandle, connectionID, apiKey, meta)
 		if err != nil {
-			resolveSpan.RecordError(err)
 			return nil, fmt.Errorf("building client for %s: %w", wl.Upstream, err)
 		}
 		ws.Add(sdk.UpstreamInfo{
@@ -202,8 +233,7 @@ func (wr *WorkspaceResolver) resolveMiss(ctx context.Context, session *UserSessi
 		}, client)
 	}
 
-	resolveSpan.SetAttributes(attribute.Int("wasteland.count", len(meta.Wastelands)))
-	wr.cacheWorkspace(session.ConnectionID, ws)
+	wr.cacheWorkspace(connectionID, ws)
 	return ws, nil
 }