Make the home page's AS name search work (closes #151)

The AS Name Search card on the home page said the search was coming soon.
It now asks the new GET /api/v1/search/as?q=<text> and lists the matches
as links to their AS pages. asinfo.Search ignores case, returns the first
matches up to a limit in AS number order, and counts all matches. An
empty q answers 400.

When the database has no record of an AS, its page and /api/v1/as/{asn}
take its handle and description from asinfo and still list its prefixes.
They answer 404 only for an AS with no record, no asinfo entry and no
prefix. AS 0 means no known origin: it always answers 404, and the search
never lists it.

Model: opus-5-5

internal/database/database.go

@@ -21,6 +21,7 @@ import (
 
 	"git.eeqj.de/sneak/routewatch/internal/config"
 	"git.eeqj.de/sneak/routewatch/internal/logger"
+	"git.eeqj.de/sneak/routewatch/internal/ristypes"
 	"git.eeqj.de/sneak/routewatch/pkg/asinfo"
 	_ "github.com/mattn/go-sqlite3" // CGO SQLite driver
 )
@@ -1748,9 +1749,21 @@ func (d *Database) GetASDetails(asn int) (*ASN, []LiveRoute, error) {
 // GetASDetailsContext returns the AS and the prefixes it originates, the IPv4
 // ones first, each once with the time of its newest route. It makes two index
 // searches per prefix, however many peers carry the prefix.
+//
+// The routes of an AS can be stored before its record in the asns table. When
+// the AS has no record, its handle and description come from the AS info
+// lookup, and it has no seen times. An AS with no record, no lookup entry and
+// no prefix is ErrNoRoute.
+//
+// ristypes.NoOrigin means no known origin, not an AS, so it is ErrNoRoute
+// whatever is stored.
 func (d *Database) GetASDetailsContext(
 	ctx context.Context, asn int,
 ) (*ASN, []LiveRoute, error) {
+	if asn == ristypes.NoOrigin {
+		return nil, nil, fmt.Errorf("%w: AS%d", ErrNoRoute, asn)
+	}
+
 	// Get AS information
 	var (
 		asnInfo             ASN
@@ -1763,17 +1776,28 @@ func (d *Database) GetASDetailsContext(
 		asn,
 	).Scan(&asnInfo.ASN, &handle, &description, &asnInfo.FirstSeen,
 		&asnInfo.LastSeen)
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, nil, fmt.Errorf("%w: AS%d", ErrNoRoute, asn)
+
+	// known is whether the asns table or the AS info lookup holds the AS.
+	known := true
+
+	switch {
+	case errors.Is(err, sql.ErrNoRows):
+		asnInfo.ASN = asn
+
+		info, ok := asinfo.Get(asn)
+		if ok {
+			asnInfo.Handle = info.Handle
+			asnInfo.Description = info.Description
 		}
 
+		known = ok
+	case err != nil:
 		return nil, nil, fmt.Errorf("failed to query AS: %w", err)
+	default:
+		asnInfo.Handle = handle.String
+		asnInfo.Description = description.String
 	}
 
-	asnInfo.Handle = handle.String
-	asnInfo.Description = description.String
-
 	allPrefixes, err := d.originPrefixes(ctx, asn, ipVersionV4)
 	if err != nil {
 		return &asnInfo, nil, err
@@ -1784,7 +1808,13 @@ func (d *Database) GetASDetailsContext(
 		return &asnInfo, allPrefixes, err
 	}
 
-	return &asnInfo, append(allPrefixes, prefixesV6...), nil
+	allPrefixes = append(allPrefixes, prefixesV6...)
+
+	if !known && len(allPrefixes) == 0 {
+		return nil, nil, fmt.Errorf("%w: AS%d", ErrNoRoute, asn)
+	}
+
+	return &asnInfo, allPrefixes, nil
 }
 
 // ASPeer represents a peering relationship with another AS including handle,

internal/database/database_internal_test.go

@@ -20,6 +20,7 @@ import (
 
 	"git.eeqj.de/sneak/routewatch/internal/config"
 	"git.eeqj.de/sneak/routewatch/internal/logger"
+	"git.eeqj.de/sneak/routewatch/pkg/asinfo"
 	"github.com/mattn/go-sqlite3"
 )
 
@@ -1699,6 +1700,85 @@ func TestGetASDetailsListsEachPrefixOnce(t *testing.T) {
 	}
 }
 
+// TestGetASDetailsOfASNotInDatabase asks for ASes that the database has no
+// record of, some with stored routes. Each gets the prefixes of its routes and
+// no seen times. One that the AS info lookup knows gets its handle and
+// description from it. An AS with no record, no lookup entry and no route is
+// ErrNoRoute. Before the fix every AS with no record was ErrNoRoute.
+func TestGetASDetailsOfASNotInDatabase(t *testing.T) {
+	t.Parallel()
+
+	db, err := New(&config.Config{StateDir: t.TempDir()}, logger.New())
+	if err != nil {
+		t.Fatalf("failed to create database: %v", err)
+	}
+	defer func() { _ = db.Close() }()
+
+	ts := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
+
+	tests := []struct {
+		asn      int
+		listed   bool     // in the AS info lookup
+		prefixes []string // of the routes stored for the AS
+	}{
+		{15169, true, []string{"192.0.2.0/24"}},
+		{13335, true, nil},
+		{4200000000, false, []string{"198.51.100.0/24"}},
+	}
+
+	var routes []*LiveRoute
+
+	for _, tt := range tests {
+		if _, ok := asinfo.Get(tt.asn); ok != tt.listed {
+			t.Fatalf("AS%d in the AS info data: %t, want %t", tt.asn, ok, tt.listed)
+		}
+
+		for _, prefix := range tt.prefixes {
+			routes = append(routes, mkV4Route(t, prefix, tt.asn, ts))
+		}
+	}
+
+	err = db.UpsertLiveRouteBatch(routes)
+	if err != nil {
+		t.Fatalf("UpsertLiveRouteBatch: %v", err)
+	}
+
+	for _, tt := range tests {
+		got, prefixes, err := db.GetASDetails(tt.asn)
+		if err != nil {
+			t.Errorf("GetASDetails(%d): %v", tt.asn, err)
+
+			continue
+		}
+
+		want := ASN{ASN: tt.asn}
+		if info, ok := asinfo.Get(tt.asn); ok {
+			want.Handle, want.Description = info.Handle, info.Description
+		}
+
+		var gotPrefixes []string
+		for _, route := range prefixes {
+			gotPrefixes = append(gotPrefixes, route.Prefix)
+		}
+
+		if *got != want || !slices.Equal(gotPrefixes, tt.prefixes) {
+			t.Errorf("GetASDetails(%d) = %+v with prefixes %v, want %+v with %v",
+				tt.asn, *got, gotPrefixes, want, tt.prefixes)
+		}
+	}
+
+	const absentASN = 4200000001 // no record, no lookup entry and no route
+
+	if _, ok := asinfo.Get(absentASN); ok {
+		t.Fatalf("AS%d is in the AS info data", absentASN)
+	}
+
+	_, _, err = db.GetASDetails(absentASN)
+	if !errors.Is(err, ErrNoRoute) {
+		t.Errorf("GetASDetails(%d): error %v, want %v", absentASN, err, ErrNoRoute)
+	}
+}
+
 // TestASPrefixQueriesUseCoveringIndexes checks the plan of each query that
 // lists the prefixes an AS originates: a search of a covering index and no
 // temporary B-tree, so the list reads one index entry per prefix, not one

internal/database/models.go

@@ -28,9 +28,10 @@ type ASN struct {
 	RIRRegDate  *time.Time `json:"rir_registration_date,omitempty"`
 	RIRLastMod  *time.Time `json:"rir_last_modified,omitempty"`
 	WHOISRaw    string     `json:"whois_raw,omitempty"`
-	// Timestamps
-	FirstSeen      time.Time  `json:"first_seen"`
-	LastSeen       time.Time  `json:"last_seen"`
+	// Timestamps. They are zero, and left out of JSON, for an AS that has no
+	// record in the asns table.
+	FirstSeen      time.Time  `json:"first_seen,omitzero"`
+	LastSeen       time.Time  `json:"last_seen,omitzero"`
 	WHOISUpdatedAt *time.Time `json:"whois_updated_at,omitempty"`
 }
 

internal/ristypes/ris.go

@@ -39,12 +39,16 @@ type ASPath struct {
 	Set []int
 }
 
+// NoOrigin is the origin AS of a route whose origin is not known. AS 0 is
+// reserved, so no AS has this number.
+const NoOrigin = 0
+
 // Origin returns the AS that originated the route: the last AS of the
-// sequence, or 0 (none) when the path ends in a set of several members or is
+// sequence, or NoOrigin when the path ends in a set of several members or is
 // empty.
 func (p *ASPath) Origin() int {
 	if len(p.Set) > 0 || len(p.Sequence) == 0 {
-		return 0
+		return NoOrigin
 	}
 
 	return p.Sequence[len(p.Sequence)-1]

internal/server/handlers.go

@@ -16,6 +16,7 @@ import (
 
 	"git.eeqj.de/sneak/routewatch/internal/database"
 	"git.eeqj.de/sneak/routewatch/internal/metrics"
+	"git.eeqj.de/sneak/routewatch/internal/ristypes"
 	"git.eeqj.de/sneak/routewatch/internal/streamer"
 	"git.eeqj.de/sneak/routewatch/internal/templates"
 	asinfo "git.eeqj.de/sneak/routewatch/pkg/asinfo"
@@ -56,10 +57,18 @@ const (
 // Error messages an answer sends, in place of the error behind it where there
 // is one.
 const (
-	invalidPrefixMessage   = "Invalid prefix"
-	hostNotResolvedMessage = "could not resolve host name"
-	hostNotPublicMessage   = "host name has no public address"
-	tooManyTargetsMessage  = "Too many addresses or host names"
+	invalidPrefixMessage      = "Invalid prefix"
+	hostNotResolvedMessage    = "could not resolve host name"
+	hostNotPublicMessage      = "host name has no public address"
+	tooManyTargetsMessage     = "Too many addresses or host names"
+	searchQueryMissingMessage = "Missing search query"
+)
+
+// The AS name search reads the text it looks for from the URL query parameter
+// asSearchQueryParam, and answers with at most maxASSearchResults matches.
+const (
+	asSearchQueryParam = "q"
+	maxASSearchResults = 50
 )
 
 // IP versions as database.LiveRoute.IPVersion records them.
@@ -1001,11 +1010,12 @@ func (s *Server) handleASDetailJSON() http.HandlerFunc {
 	}
 }
 
-// splitRoutesByIPVersion groups routes into the IPv4 and the IPv6 ones.
+// splitRoutesByIPVersion groups routes into the IPv4 and the IPv6 ones. Neither
+// group is nil, so that a JSON answer holds [] for an empty one and not null.
 func splitRoutesByIPVersion(
 	routes []database.LiveRoute,
 ) ([]database.LiveRoute, []database.LiveRoute) {
-	var ipv4Routes, ipv6Routes []database.LiveRoute
+	ipv4Routes, ipv6Routes := []database.LiveRoute{}, []database.LiveRoute{}
 
 	for _, route := range routes {
 		if route.IPVersion == ipVersionV4 {
@@ -1105,6 +1115,56 @@ func (s *Server) handlePrefixDetailJSON() http.HandlerFunc {
 	}
 }
 
+// ASSearchResponse is the answer to an AS name search: the text searched for,
+// the number of ASes that match it, and the first maxASSearchResults of them in
+// AS number order.
+type ASSearchResponse struct {
+	Query   string        `json:"query"`
+	Total   int           `json:"total"`
+	Results []asinfo.Info `json:"results"`
+}
+
+// handleASSearch returns a handler that searches the AS list built into
+// asinfo for the text in the q parameter, without its leading and trailing
+// spaces. It answers 400 when no text is left.
+func (s *Server) handleASSearch() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		query := strings.TrimSpace(r.URL.Query().Get(asSearchQueryParam))
+		if query == "" {
+			s.writeJSONError(w, http.StatusBadRequest, searchQueryMissingMessage)
+
+			return
+		}
+
+		// AS 0 means no known origin and has no AS page, so the answer leaves
+		// it out. The matches come in AS number order, so AS 0 can only be the
+		// first. The search asks for one match more than the answer holds, to
+		// take its place.
+		results, total := asinfo.Search(query, maxASSearchResults+1)
+		if len(results) > 0 && results[0].ASN == ristypes.NoOrigin {
+			results = results[1:]
+			total--
+		}
+
+		results = results[:min(len(results), maxASSearchResults)]
+
+		// results is an empty list rather than nil when nothing matches, so
+		// that the answer holds [] and not null.
+		if results == nil {
+			results = []asinfo.Info{}
+		}
+
+		err := writeJSONSuccess(w, ASSearchResponse{
+			Query:   query,
+			Total:   total,
+			Results: results,
+		})
+		if err != nil {
+			s.logger.Error("Failed to encode AS search results", "error", err)
+		}
+	}
+}
+
 // handleASDetail returns a handler that serves the AS detail HTML page
 func (s *Server) handleASDetail() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {

internal/server/handlers_internal_test.go

@@ -19,6 +19,7 @@ import (
 	"git.eeqj.de/sneak/routewatch/internal/database"
 	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"git.eeqj.de/sneak/routewatch/internal/metrics"
+	"git.eeqj.de/sneak/routewatch/internal/ristypes"
 	"git.eeqj.de/sneak/routewatch/internal/streamer"
 	"git.eeqj.de/sneak/routewatch/pkg/asinfo"
 )
@@ -26,6 +27,7 @@ import (
 // The prefix and peer addresses the prefix page tests store routes for.
 const (
 	testPrefixV4 = "192.0.2.0/24"
+	testPrefixV6 = "2001:db8::/32"
 	testPeerV4   = "198.51.100.1"
 	testPeerV6   = "2001:db8::1"
 )
@@ -194,7 +196,7 @@ func TestStatsHandlersAnswerFromMemory(t *testing.T) {
 }
 
 // newServerWithTestRoutes returns a server on a new database that holds a
-// route for testPrefixV4 and one for 2001:db8::/32.
+// route for testPrefixV4 and one for testPrefixV6.
 func newServerWithTestRoutes(t *testing.T) *Server {
 	t.Helper()
 
@@ -214,7 +216,7 @@ func newServerWithTestRoutes(t *testing.T) *Server {
 			NextHop: testPeerV4, LastUpdated: ts,
 		},
 		{
-			Prefix: "2001:db8::/32", MaskLength: 32, IPVersion: 6,
+			Prefix: testPrefixV6, MaskLength: 32, IPVersion: 6,
 			OriginASN: 64501, PeerIP: testPeerV6, ASPath: []int{64501},
 			NextHop: testPeerV6, LastUpdated: ts,
 		},
@@ -1166,6 +1168,389 @@ func TestIPLookupHidesPrivateAddresses(t *testing.T) {
 	}
 }
 
+// asSearchPath is the path of the AS name search.
+const asSearchPath = "/api/v1/search/as"
+
+// searchAS sends an AS name search with the URL query rawQuery through s's
+// router, expects a 200 answer, and returns its data.
+func searchAS(t *testing.T, s *Server, rawQuery string) ASSearchResponse {
+	t.Helper()
+
+	rec := httptest.NewRecorder()
+	s.router.ServeHTTP(rec, httptest.NewRequestWithContext(
+		t.Context(), http.MethodGet, asSearchPath+"?"+rawQuery, nil))
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("%s: status %d, want %d; body %s",
+			rawQuery, rec.Code, http.StatusOK, rec.Body)
+	}
+
+	var body struct {
+		Data ASSearchResponse `json:"data"`
+	}
+
+	err := json.Unmarshal(rec.Body.Bytes(), &body)
+	if err != nil {
+		t.Fatalf("%s: decoding the answer %q: %v", rawQuery, rec.Body, err)
+	}
+
+	return body.Data
+}
+
+// TestASSearchAnswersMatches searches for Cloudflare's handle in lower case,
+// with spaces around it, and expects AS13335 among the matches. Before the fix
+// there was no AS name search, and the home page's search card said it was
+// coming soon (https://git.eeqj.de/sneak/routewatch/issues/151).
+func TestASSearchAnswersMatches(t *testing.T) {
+	t.Parallel()
+
+	const query = "cloudflarenet"
+
+	data := searchAS(t, newServerWithTestRoutes(t), "q=%20"+query+"%20")
+
+	if data.Query != query {
+		t.Errorf("query %q, want %q", data.Query, query)
+	}
+
+	if data.Total != len(data.Results) {
+		t.Errorf("total %d, but %d results", data.Total, len(data.Results))
+	}
+
+	cloudflare := asinfo.Info{
+		ASN: 13335, Handle: "CLOUDFLARENET", Description: "Cloudflare, Inc.",
+	}
+	if !slices.Contains(data.Results, cloudflare) {
+		t.Errorf("results %v do not hold %v", data.Results, cloudflare)
+	}
+}
+
+// TestASSearchAnswersEmptyListWhenNothingMatches expects a search that matches
+// nothing to answer 200 with a total of 0 and an empty list, not null.
+func TestASSearchAnswersEmptyListWhenNothingMatches(t *testing.T) {
+	t.Parallel()
+
+	data := searchAS(t, newServerWithTestRoutes(t), "q=XYZABC123456")
+
+	if data.Total != 0 || data.Results == nil || len(data.Results) != 0 {
+		t.Errorf("total %d and results %#v, want 0 and an empty list",
+			data.Total, data.Results)
+	}
+}
+
+// TestASSearchAnswers400ForEmptyQuery expects a search with no q, an empty q
+// or a q of only spaces to answer 400 with the JSON error body.
+func TestASSearchAnswers400ForEmptyQuery(t *testing.T) {
+	t.Parallel()
+
+	s := newServerWithTestRoutes(t)
+
+	for _, path := range []string{
+		asSearchPath, asSearchPath + "?q=", asSearchPath + "?q=%20%20",
+	} {
+		rec := httptest.NewRecorder()
+		s.router.ServeHTTP(rec, httptest.NewRequestWithContext(
+			t.Context(), http.MethodGet, path, nil))
+
+		if rec.Code != http.StatusBadRequest {
+			t.Errorf("%s: status %d, want %d; body %s",
+				path, rec.Code, http.StatusBadRequest, rec.Body)
+		}
+
+		checkJSONErrorCode(t, path, rec, http.StatusBadRequest)
+		checkJSONErrorMessage(t, path, rec, searchQueryMissingMessage)
+	}
+}
+
+// TestASSearchShowsFirstMatchesAndTotal searches for a word with more matches
+// than an answer holds, and expects the first maxASSearchResults of them, in
+// AS number order, and the number of all of them.
+func TestASSearchShowsFirstMatchesAndTotal(t *testing.T) {
+	t.Parallel()
+
+	const query = "university"
+
+	all, _ := asinfo.Search(query, asinfo.Total())
+	if len(all) <= maxASSearchResults {
+		t.Fatalf("Search(%q) has %d matches; the test needs more than %d",
+			query, len(all), maxASSearchResults)
+	}
+
+	data := searchAS(t, newServerWithTestRoutes(t), "q="+query)
+
+	if data.Total != len(all) {
+		t.Errorf("total %d, want %d", data.Total, len(all))
+	}
+
+	if !slices.Equal(data.Results, all[:maxASSearchResults]) {
+		t.Errorf("results %v, want the first %d matches %v",
+			data.Results, maxASSearchResults, all[:maxASSearchResults])
+	}
+}
+
+// The AS numbers the AS detail tests ask for. storedASN originates the route
+// for testPrefixV4 and is in the database. routeOnlyASN originates the route
+// for testPrefixV6, but the database has no record of the AS itself, as when
+// a route is stored before its AS. builtInOnlyASN is in the AS list built into
+// asinfo but not in the database. unknownASN is in neither.
+const (
+	storedASN      = 64500
+	routeOnlyASN   = 64501
+	builtInOnlyASN = 15169
+	unknownASN     = 4200000000
+)
+
+// zeroDate is how a page writes a time that was never set.
+const zeroDate = "0001-01-01"
+
+// firstSeenCard is the label of the AS page's first-seen date.
+const firstSeenCard = `<div class="info-label">First Seen</div>`
+
+// newServerWithStoredAS returns newServerWithTestRoutes's server with storedASN
+// added to the database. It fails the test when the AS list built into asinfo
+// lacks routeOnlyASN or builtInOnlyASN, or holds unknownASN.
+func newServerWithStoredAS(t *testing.T) *Server {
+	t.Helper()
+
+	for _, asn := range []int{routeOnlyASN, builtInOnlyASN} {
+		if _, ok := asinfo.Get(asn); !ok {
+			t.Fatalf("AS%d is not in the AS info data", asn)
+		}
+	}
+
+	if _, ok := asinfo.Get(unknownASN); ok {
+		t.Fatalf("AS%d is in the AS info data", unknownASN)
+	}
+
+	s := newServerWithTestRoutes(t)
+
+	_, err := s.db.GetOrCreateASN(storedASN, time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC))
+	if err != nil {
+		t.Fatalf("GetOrCreateASN: %v", err)
+	}
+
+	return s
+}
+
+// TestASDetailJSONAnswersBuiltInAS asks /api/v1/as/ for each of the ASes above.
+// All but unknownASN answer 200 with the handle and description from the
+// built-in AS list and their prefixes, as lists even when empty. Only storedASN
+// has a first_seen time. unknownASN answers 404. Before the fix builtInOnlyASN
+// and routeOnlyASN answered 404 too
+// (https://git.eeqj.de/sneak/routewatch/issues/151).
+func TestASDetailJSONAnswersBuiltInAS(t *testing.T) {
+	t.Parallel()
+
+	s := newServerWithStoredAS(t)
+
+	tests := []struct {
+		asn           int
+		wantCode      int
+		wantPrefixes  []string
+		wantFirstSeen bool
+	}{
+		{storedASN, http.StatusOK, []string{testPrefixV4}, true},
+		{routeOnlyASN, http.StatusOK, []string{testPrefixV6}, false},
+		{builtInOnlyASN, http.StatusOK, nil, false},
+		{unknownASN, http.StatusNotFound, nil, false},
+	}
+
+	for _, tt := range tests {
+		path := "/api/v1/as/" + strconv.Itoa(tt.asn)
+		rec := httptest.NewRecorder()
+		s.router.ServeHTTP(rec, httptest.NewRequestWithContext(
+			t.Context(), http.MethodGet, path, nil))
+
+		if rec.Code != tt.wantCode {
+			t.Errorf("%s: status %d, want %d; body %s",
+				path, rec.Code, tt.wantCode, rec.Body)
+
+			continue
+		}
+
+		if tt.wantCode != http.StatusOK {
+			checkJSONErrorCode(t, path, rec, tt.wantCode)
+
+			continue
+		}
+
+		//nolint:tagliatelle // field names are the existing JSON API
+		var body struct {
+			Data struct {
+				ASN          database.ASN         `json:"asn"`
+				IPv4Prefixes []database.LiveRoute `json:"ipv4_prefixes"`
+				IPv6Prefixes []database.LiveRoute `json:"ipv6_prefixes"`
+			} `json:"data"`
+		}
+
+		err := json.Unmarshal(rec.Body.Bytes(), &body)
+		if err != nil {
+			t.Errorf("%s: decoding the answer %q: %v", path, rec.Body, err)
+
+			continue
+		}
+
+		info, _ := asinfo.Get(tt.asn)
+		got := body.Data.ASN
+
+		if got.ASN != tt.asn || got.Handle != info.Handle ||
+			got.Description != info.Description {
+			t.Errorf("%s: AS %d %q %q, want %d %q %q", path, got.ASN,
+				got.Handle, got.Description, tt.asn, info.Handle, info.Description)
+		}
+
+		if body.Data.IPv4Prefixes == nil || body.Data.IPv6Prefixes == nil {
+			t.Errorf("%s: a prefix list is null; body %s", path, rec.Body)
+		}
+
+		routes := slices.Concat(body.Data.IPv4Prefixes, body.Data.IPv6Prefixes)
+
+		gotPrefixes := make([]string, 0, len(routes))
+		for _, route := range routes {
+			gotPrefixes = append(gotPrefixes, route.Prefix)
+		}
+
+		if !slices.Equal(gotPrefixes, tt.wantPrefixes) {
+			t.Errorf("%s: prefixes %v, want %v", path, gotPrefixes, tt.wantPrefixes)
+		}
+
+		gotFirstSeen := strings.Contains(rec.Body.String(), `"first_seen"`)
+		if gotFirstSeen != tt.wantFirstSeen {
+			t.Errorf("%s: has first_seen %t, want %t; body %s",
+				path, gotFirstSeen, tt.wantFirstSeen, rec.Body)
+		}
+	}
+}
+
+// TestASDetailPageShowsBuiltInAS asks /as/ for each of the ASes above. All but
+// unknownASN answer 200 with the handle and description from the built-in AS
+// list. storedASN and routeOnlyASN list their prefixes, and builtInOnlyASN says
+// the AS announces none. Only storedASN shows a first-seen date, and no page
+// shows a date that was never set. unknownASN answers 404. Before the fix
+// builtInOnlyASN and routeOnlyASN answered 404 too
+// (https://git.eeqj.de/sneak/routewatch/issues/151).
+func TestASDetailPageShowsBuiltInAS(t *testing.T) {
+	t.Parallel()
+
+	s := newServerWithStoredAS(t)
+
+	tests := []struct {
+		asn           int
+		wantCode      int
+		wantText      string
+		wantFirstSeen bool
+	}{
+		{storedASN, http.StatusOK, testPrefixV4, true},
+		{routeOnlyASN, http.StatusOK, testPrefixV6, false},
+		{builtInOnlyASN, http.StatusOK, "No prefixes announced by this AS", false},
+		{unknownASN, http.StatusNotFound, "", false},
+	}
+
+	for _, tt := range tests {
+		path := "/as/" + strconv.Itoa(tt.asn)
+		rec := httptest.NewRecorder()
+		s.router.ServeHTTP(rec, httptest.NewRequestWithContext(
+			t.Context(), http.MethodGet, path, nil))
+
+		if rec.Code != tt.wantCode {
+			t.Errorf("%s: status %d, want %d; body %s",
+				path, rec.Code, tt.wantCode, rec.Body)
+
+			continue
+		}
+
+		if tt.wantCode != http.StatusOK {
+			continue
+		}
+
+		info, _ := asinfo.Get(tt.asn)
+		page := rec.Body.String()
+
+		for _, want := range []string{
+			html.EscapeString(info.Handle),
+			html.EscapeString(info.Description),
+			tt.wantText,
+		} {
+			if !strings.Contains(page, want) {
+				t.Errorf("%s: page does not show %q", path, want)
+			}
+		}
+
+		if strings.Contains(page, zeroDate) {
+			t.Errorf("%s: page shows the date %s", path, zeroDate)
+		}
+
+		gotFirstSeen := strings.Contains(page, firstSeenCard)
+		if gotFirstSeen != tt.wantFirstSeen {
+			t.Errorf("%s: shows a first-seen date %t, want %t",
+				path, gotFirstSeen, tt.wantFirstSeen)
+		}
+	}
+}
+
+// TestNoOriginHasNoASAnswers stores a route with no known origin, which has
+// origin AS 0 (https://git.eeqj.de/sneak/routewatch/issues/75). It expects
+// /as/0 and /api/v1/as/0 to answer 404. It expects a search for "iana" to leave
+// AS 0 out of its results and its total, although the AS list built into
+// asinfo holds AS 0. That search has more matches than an answer holds, so it
+// still lists maxASSearchResults of them.
+func TestNoOriginHasNoASAnswers(t *testing.T) {
+	t.Parallel()
+
+	const (
+		noOriginPrefix = "203.0.113.0/24"
+		query          = "iana"
+	)
+
+	s := newServerWithTestRoutes(t)
+
+	err := s.db.UpsertLiveRouteBatch([]*database.LiveRoute{{
+		Prefix: noOriginPrefix, MaskLength: 24, IPVersion: 4,
+		OriginASN: ristypes.NoOrigin, PeerIP: testPeerV4,
+		ASPath: []int{64500, 64501, 64502}, NextHop: testPeerV4,
+		LastUpdated: time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC),
+	}})
+	if err != nil {
+		t.Fatalf("UpsertLiveRouteBatch: %v", err)
+	}
+
+	asn := strconv.Itoa(ristypes.NoOrigin)
+
+	for _, path := range []string{"/as/" + asn, "/api/v1/as/" + asn} {
+		rec := httptest.NewRecorder()
+		s.router.ServeHTTP(rec, httptest.NewRequestWithContext(
+			t.Context(), http.MethodGet, path, nil))
+
+		if rec.Code != http.StatusNotFound {
+			t.Errorf("%s: status %d, want %d; body %s",
+				path, rec.Code, http.StatusNotFound, rec.Body)
+		}
+	}
+
+	first, total := asinfo.Search(query, 1)
+	if len(first) != 1 || first[0].ASN != ristypes.NoOrigin {
+		t.Fatalf("AS%d is not the first match for %q in the AS info data",
+			ristypes.NoOrigin, query)
+	}
+
+	data := searchAS(t, s, "q="+query)
+
+	for _, info := range data.Results {
+		if info.ASN == ristypes.NoOrigin {
+			t.Errorf("the search for %q lists AS%d", query, info.ASN)
+		}
+	}
+
+	if data.Total != total-1 {
+		t.Errorf("the search for %q has a total of %d, want %d",
+			query, data.Total, total-1)
+	}
+
+	if len(data.Results) != maxASSearchResults {
+		t.Errorf("the search for %q lists %d matches, want %d",
+			query, len(data.Results), maxASSearchResults)
+	}
+}
+
 // settledGoroutineCount lets transient goroutines finish, then reports the
 // current count.
 func settledGoroutineCount() int {

internal/server/routes.go

@@ -87,6 +87,7 @@ func (s *Server) setupRoutes() {
 		r.Get("/ip/{ip}", s.handleIPLookup())
 		r.Get("/as/{asn}", s.handleASDetailJSON())
 		r.Get("/prefix/{prefix}/{len}", s.handlePrefixDetailJSON())
+		r.Get("/search/as", s.handleASSearch())
 	})
 
 	s.router = r

internal/server/server.go

@@ -1,4 +1,8 @@
-// Package server provides HTTP endpoints for status monitoring and statistics
+// Package server serves RouteWatch's web pages and JSON API:
+//   - the home page, the status figures and the health check
+//   - the AS, prefix and prefix length pages, and the JSON answers behind them
+//   - the IP lookups
+//   - the AS name search
 package server
 
 import (

internal/templates/as_detail.html

@@ -233,10 +233,12 @@
                 <div class="info-label">Peer ASNs</div>
                 <div class="info-value">{{.PeerCount}}</div>
             </div>
+            {{if not .ASN.FirstSeen.IsZero}}
             <div class="info-card">
                 <div class="info-label">First Seen</div>
                 <div class="info-value">{{.ASN.FirstSeen.Format "2006-01-02"}}</div>
             </div>
+            {{end}}
         </div>
 
         {{if .IPv4Prefixes}}

internal/templates/index.html

@@ -174,6 +174,38 @@
         #asname-results .search-message {
             font-size: 13px;
         }
+        #asname-results .error {
+            color: #c00;
+        }
+        .asname-list {
+            list-style: none;
+            margin: 12px 0 0 0;
+            padding: 0;
+            max-height: 400px;
+            overflow-y: auto;
+        }
+        .asname-list li {
+            border-bottom: 1px solid #eee;
+        }
+        .asname-list a {
+            display: block;
+            padding: 8px 4px;
+            color: #2c3e50;
+            text-decoration: none;
+            font-size: 14px;
+        }
+        .asname-list a:hover {
+            background: #f5f5f5;
+        }
+        .asname-list .asn {
+            font-weight: 600;
+            color: #3498db;
+        }
+        .asname-list .description {
+            display: block;
+            color: #7f8c8d;
+            font-size: 12px;
+        }
 
         /* IP Lookup result */
         .ip-result {
@@ -306,7 +338,7 @@
                     <input type="text" id="asname-input" placeholder="e.g., Google, Cloudflare" autocomplete="off">
                     <button type="submit">Search</button>
                 </form>
-                <p class="search-hint">Search for autonomous systems by organization name</p>
+                <p class="search-hint">Search for autonomous systems by organization name or handle</p>
                 <div id="asname-results"></div>
             </div>
 
@@ -387,24 +419,82 @@
             }
         });
 
-        // AS name search
+        // AS name search. The handles and descriptions come from outside data,
+        // so the results are built with textContent, never innerHTML.
+        const asNameResults = document.getElementById('asname-results');
+
+        // Replace the search results with one line of text.
+        function showASNameMessage(text, className) {
+            const line = document.createElement('p');
+            line.className = className;
+            line.textContent = text;
+            asNameResults.replaceChildren(line);
+        }
+
+        // List the matches of a search answer, each as a link to its AS page,
+        // and say how many more matched than the answer holds.
+        function showASNameMatches(data) {
+            if (data.total === 0) {
+                showASNameMessage('No AS matches "' + data.query + '".', 'search-message');
+                return;
+            }
+
+            const list = document.createElement('ul');
+            list.className = 'asname-list';
+            for (const match of data.results) {
+                const asn = document.createElement('span');
+                asn.className = 'asn';
+                asn.textContent = 'AS' + match.asn;
+
+                const description = document.createElement('span');
+                description.className = 'description';
+                description.textContent = match.description;
+
+                const link = document.createElement('a');
+                link.href = '/as/' + match.asn;
+                link.append(asn, ' ' + match.handle, description);
+
+                const item = document.createElement('li');
+                item.append(link);
+                list.append(item);
+            }
+            asNameResults.replaceChildren(list);
+
+            const more = data.total - data.results.length;
+            if (more > 0) {
+                const line = document.createElement('p');
+                line.className = 'search-message';
+                line.textContent = more.toLocaleString() + ' more matched. Narrow the search to see them.';
+                asNameResults.append(line);
+            }
+        }
+
         document.getElementById('asname-form').addEventListener('submit', function(e) {
             e.preventDefault();
             const query = document.getElementById('asname-input').value.trim();
             if (!query) return;
 
-            const resultsDiv = document.getElementById('asname-results');
-            resultsDiv.innerHTML = '<p class="loading">Searching...</p>';
-
-            // Use a simple client-side search against the asinfo data
-            // For now, redirect to AS page if it looks like an ASN
-            if (/^\d+$/.test(query)) {
-                window.location.href = '/as/' + query;
+            // A number, or AS and a number, opens that AS's page
+            const asn = query.replace(/^AS/i, '');
+            if (/^\d+$/.test(asn)) {
+                window.location.href = '/as/' + asn;
                 return;
             }
 
-            // Show a message that server-side search is coming
-            resultsDiv.innerHTML = '<p class="search-message">AS name search coming soon. For now, try an AS number.</p>';
+            showASNameMessage('Searching...', 'loading');
+
+            fetch('/api/v1/search/as?q=' + encodeURIComponent(query))
+                .then(response => response.json())
+                .then(response => {
+                    if (response.status === 'error') {
+                        showASNameMessage('Error: ' + response.error.msg, 'error');
+                    } else {
+                        showASNameMatches(response.data);
+                    }
+                })
+                .catch(error => {
+                    showASNameMessage('Error: ' + error.message, 'error');
+                });
         });
 
         // IP lookup