update

config.sample.yaml

···
+database:
+  type: "postgres"  # or "sqlite"
+  path: "postgres://atscanner:YOUR_PASSWORD@localhost:5432/atscanner?sslmode=disable"
+  # For SQLite: path: "atscan.db"
+
+plc:
+  directory_url: "https://plc.directory"
+  scan_interval: "5s"
+  bundle_dir: "./plc_bundles"
+  use_cache: true
+  index_dids: true
+
+pds:
+  scan_interval: "30m"
+  timeout: "30s"
+  workers: 20
+  recheck_interval: "1.5h"
+  scan_retention: 20
+
+api:
+  host: "0.0.0.0"
+  port: 8080

internal/api/handlers.go

···
 	resp.json(stats)
 }
 
+// ===== GLOBAL DID HANDLER =====
+
+// extractHandle safely extracts the handle from a PLC operation
+func extractHandle(op *plc.PLCOperation) string {
+	if op == nil || op.Operation == nil {
+		return ""
+	}
+
+	// Get "alsoKnownAs"
+	aka, ok := op.Operation["alsoKnownAs"].([]interface{})
+	if !ok {
+		return ""
+	}
+
+	// Find the handle (e.g., "at://handle.bsky.social")
+	for _, item := range aka {
+		if handle, ok := item.(string); ok {
+			if strings.HasPrefix(handle, "at://") {
+				return strings.TrimPrefix(handle, "at://")
+			}
+		}
+	}
+	return ""
+}
+
+// extractPDS safely extracts the PDS endpoint from a PLC operation
+func extractPDS(op *plc.PLCOperation) string {
+	if op == nil || op.Operation == nil {
+		return ""
+	}
+
+	// Get "services"
+	services, ok := op.Operation["services"].(map[string]interface{})
+	if !ok {
+		return ""
+	}
+
+	// Get "atproto_pds"
+	pdsService, ok := services["atproto_pds"].(map[string]interface{})
+	if !ok {
+		return ""
+	}
+
+	// Get "endpoint"
+	if endpoint, ok := pdsService["endpoint"].(string); ok {
+		return endpoint
+	}
+
+	return ""
+}
+
+// handleGetGlobalDID provides a consolidated view of a DID
+func (s *Server) handleGetGlobalDID(w http.ResponseWriter, r *http.Request) {
+	resp := newResponse(w)
+	vars := mux.Vars(r)
+	did := vars["did"]
+	ctx := r.Context()
+
+	// --- 1. Get Combined DID Info (from dids and pds_repos) ---
+	didInfo, err := s.db.GetGlobalDIDInfo(ctx, did)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			// Check if DID indexing is disabled (from config)
+			if !s.plcIndexDIDs {
+				resp.error("DID not found. Note: DID indexing is disabled in configuration.", http.StatusNotFound)
+			} else {
+				resp.error("DID not found in PLC index.", http.StatusNotFound)
+			}
+		} else {
+			resp.error(err.Error(), http.StatusInternalServerError)
+		}
+		return
+	}
+
+	// --- 2. Get Latest PLC Operation (from plc_bundles) ---
+	var latestOperation *plc.PLCOperation
+	if len(didInfo.BundleNumbers) > 0 {
+		lastBundleNum := didInfo.BundleNumbers[len(didInfo.BundleNumbers)-1]
+		ops, err := s.bundleManager.LoadBundleOperations(ctx, lastBundleNum)
+		if err != nil {
+			log.Error("Failed to load bundle %d for DID %s: %v", lastBundleNum, did, err)
+		} else {
+			// Find latest operation for this DID (in reverse)
+			for i := len(ops) - 1; i >= 0; i-- {
+				if ops[i].DID == did {
+					latestOperation = &ops[i]
+					break
+				}
+			}
+		}
+	}
+
+	// --- 3. Extract Handle and PDS from latest operation ---
+	currentHandle := extractHandle(latestOperation)
+	currentPDS := extractPDS(latestOperation)
+
+	// --- 4. Combine and Respond ---
+	resp.json(map[string]interface{}{
+		"did":                  didInfo.DID,
+		"handle":               currentHandle, // NEW
+		"current_pds":          currentPDS,    // NEW
+		"plc_index_created_at": didInfo.CreatedAt,
+		"plc_bundle_history":   didInfo.BundleNumbers,
+		"pds_hosting_on":       didInfo.HostingOn, // This is the historical list from pds_repos
+		"latest_plc_operation": latestOperation,
+	})
+}
+
 // ===== DID HANDLERS =====
 
 func (s *Server) handleGetDID(w http.ResponseWriter, r *http.Request) {

internal/api/server.go

···
 	plcClient     *plc.Client
 	plcBundleDir  string
 	bundleManager *plc.BundleManager
+	plcIndexDIDs  bool
 }
 
 func NewServer(db storage.Database, apiCfg config.APIConfig, plcCfg config.PLCConfig) *Server {
···
 		plcClient:     plc.NewClient(plcCfg.DirectoryURL),
 		plcBundleDir:  plcCfg.BundleDir,
 		bundleManager: bundleManager,
+		plcIndexDIDs:  plcCfg.IndexDIDs,
 	}
 
 	s.setupRoutes()
···
 	api.HandleFunc("/pds/{endpoint}/repos", s.handleGetPDSRepos).Methods("GET")
 	api.HandleFunc("/pds/{endpoint}/repos/stats", s.handleGetPDSRepoStats).Methods("GET")
 	api.HandleFunc("/pds/repos/{did}", s.handleGetDIDRepos).Methods("GET")
+
+	// Global DID route
+	api.HandleFunc("/did/{did}", s.handleGetGlobalDID).Methods("GET")
 
 	// PLC Bundle routes
 	api.HandleFunc("/plc/bundles", s.handleGetPLCBundles).Methods("GET")

internal/storage/db.go

···
 	// DID operations
 	UpsertDID(ctx context.Context, did string, bundleNum int) error
 	GetDIDRecord(ctx context.Context, did string) (*DIDRecord, error)
+	GetGlobalDIDInfo(ctx context.Context, did string) (*GlobalDIDInfo, error)
 	AddBundleDIDs(ctx context.Context, bundleNum int, dids []string) error
 	GetTotalDIDCount(ctx context.Context) (int64, error)
 

internal/storage/postgres.go

···
 	return &record, nil
 }
 
+// GetGlobalDIDInfo retrieves consolidated DID info from 'dids' and 'pds_repos'
+func (p *PostgresDB) GetGlobalDIDInfo(ctx context.Context, did string) (*GlobalDIDInfo, error) {
+	// This query now includes a CTE to find primary endpoints and filters
+	// the 'hosting_on' aggregation to only include repos from those endpoints.
+	query := `
+		WITH primary_endpoints AS (
+		  -- First, get the ID of every "primary" PDS.
+		  -- A primary PDS is the one with the earliest 'discovered_at' timestamp
+		  -- for a given 'server_did'.
+		  SELECT DISTINCT ON (COALESCE(server_did, id::text))
+			id
+		  FROM endpoints
+		  WHERE endpoint_type = 'pds'
+		  ORDER BY COALESCE(server_did, id::text), discovered_at ASC
+		)
+		SELECT
+		  d.did,
+		  d.bundle_numbers,
+		  d.created_at,
+		  COALESCE(
+			jsonb_agg(
+			  jsonb_build_object(
+				'id', pr.id,
+				'endpoint_id', pr.endpoint_id,
+				'endpoint', e.endpoint,
+				'did', pr.did,
+				'head', pr.head,
+				'rev', pr.rev,
+				'active', pr.active,
+				'status', pr.status,
+				'first_seen', pr.first_seen AT TIME ZONE 'UTC',
+				'last_seen', pr.last_seen AT TIME ZONE 'UTC',
+				'updated_at', pr.updated_at AT TIME ZONE 'UTC'
+			  )
+			ORDER BY pr.last_seen DESC
+			) FILTER (
+				-- This filter clause ensures we only aggregate repos
+				-- where the endpoint_id is in our list of primary endpoints.
+				WHERE pr.id IS NOT NULL AND pe.id IS NOT NULL
+			),
+			'[]'::jsonb
+		  ) AS hosting_on
+		FROM
+		  dids d
+		LEFT JOIN
+		  pds_repos pr ON d.did = pr.did
+		LEFT JOIN
+		  endpoints e ON pr.endpoint_id = e.id
+		LEFT JOIN
+		  -- We join the primary_endpoints CTE. 'pe.id' will be NON-NULL
+		  -- only if the repo's endpoint_id (pr.endpoint_id) is a primary one.
+		  primary_endpoints pe ON pr.endpoint_id = pe.id
+		WHERE
+		  d.did = $1
+		GROUP BY
+		  d.did, d.bundle_numbers, d.created_at
+	`
+
+	var info GlobalDIDInfo
+	var bundleNumbersJSON []byte
+	var hostingOnJSON []byte
+
+	err := p.db.QueryRowContext(ctx, query, did).Scan(
+		&info.DID,
+		&bundleNumbersJSON,
+		&info.CreatedAt,
+		&hostingOnJSON,
+	)
+	if err != nil {
+		return nil, err // This will correctly be sql.ErrNoRows if not in 'dids'
+	}
+
+	if err := json.Unmarshal(bundleNumbersJSON, &info.BundleNumbers); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal bundle_numbers: %w", err)
+	}
+
+	if err := json.Unmarshal(hostingOnJSON, &info.HostingOn); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal hosting_on: %w", err)
+	}
+
+	return &info, nil
+}
+
 func (p *PostgresDB) AddBundleDIDs(ctx context.Context, bundleNum int, dids []string) error {
 	if len(dids) == 0 {
 		return nil

internal/storage/types.go

···
 type PDSRepo struct {
 	ID         int64     `json:"id"`
 	EndpointID int64     `json:"endpoint_id"`
+	Endpoint   string    `json:"endpoint,omitempty"`
 	DID        string    `json:"did"`
 	Head       string    `json:"head,omitempty"`
 	Rev        string    `json:"rev,omitempty"`
···
 	Active bool
 	Status string
 }
+
+type GlobalDIDInfo struct {
+	DIDRecord
+	HostingOn []*PDSRepo `json:"hosting_on"`
+}