commit 857ca378b64c8d62a128a4fa334716eceaecf96c · bretton.dev/coves

+21

.env.dev

···

       107
       107
        
       APPVIEW_PUBLIC_URL=http://127.0.0.1:8081

     

       108
       108
        
       

     

       109
       109
        
       # =============================================================================

     

       110
       110
       +
       # Coves Instance PDS Authentication

     

       111
       111
       +
       # =============================================================================

     

       112
       112
       +
       # The Coves instance needs a PDS account to write community records

     

       113
       113
       +
       # Create this account once: curl -X POST http://localhost:3001/xrpc/com.atproto.server.createAccount

     

       114
       114
       +
       PDS_INSTANCE_HANDLE=testuser123.local.coves.dev

     

       115
       115
       +
       PDS_INSTANCE_PASSWORD=test-password-123

     

       116
       116
       +
       

     

       117
       117
       +
       # =============================================================================

     

       110
       118
        
       # Development Settings

     

       111
       119
        
       # =============================================================================

     

       112
       120
        
       # Environment

     

       113
       121
        
       ENV=development

     

       114
       122
        
       NODE_ENV=development

     

       123
       123
       +
       IS_DEV_ENV=true

     

       115
       124
        
       

     

       116
       125
        
       # Logging

     

       117
       126
        
       LOG_LEVEL=debug

     

       118
       127
        
       LOG_ENABLED=true

     

       128
       128
       +
       

     

       129
       129
       +
       # =============================================================================

     

       130
       130
       +
       # PLC Directory Configuration

     

       131
       131
       +
       # =============================================================================

     

       132
       132
       +
       # URL for PLC (Public Ledger of Credentials) directory

     

       133
       133
       +
       # Only used when IS_DEV_ENV=false (production)

     

       134
       134
       +
       #

     

       135
       135
       +
       # When IS_DEV_ENV=true:  Generate did:plc:xxx locally WITHOUT registering (no PLC needed)

     

       136
       136
       +
       # When IS_DEV_ENV=false: Generate did:plc:xxx AND register with PLC_DIRECTORY_URL

     

       137
       137
       +
       #

     

       138
       138
       +
       # Production: https://plc.directory (currently Bluesky's, will transfer to third party)

     

       139
       139
       +
       PLC_DIRECTORY_URL=https://plc.directory

     

       119
       140
        
       

     

       120
       141
        
       # =============================================================================

     

       121
       142
        
       # Notes

+98 -1

cmd/server/main.go

···

       1
       1
        
       package main

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"bytes"

     

       4
       5
        
       	"context"

     

       5
       6
        
       	"database/sql"

     

       7
       7
       +
       	"encoding/json"

     

       6
       8
        
       	"fmt"

     

       9
       9
       +
       	"io"

     

       7
       10
        
       	"log"

     

       8
       11
        
       	"net/http"

     

       9
       12
        
       	"os"

     
···

       17
       20
        
       	"Coves/internal/api/handlers/oauth"

     

       18
       21
        
       	"Coves/internal/api/middleware"

     

       19
       22
        
       	"Coves/internal/api/routes"

     

       23
       23
       +
       	"Coves/internal/atproto/did"

     

       20
       24
        
       	"Coves/internal/atproto/identity"

     

       21
       25
        
       	"Coves/internal/atproto/jetstream"

     

       26
       26
       +
       	"Coves/internal/core/communities"

     

       22
       27
        
       	oauthCore "Coves/internal/core/oauth"

     

       23
       28
        
       	"Coves/internal/core/users"

     

       24
       29
        
       	postgresRepo "Coves/internal/db/postgres"

     
···

       94
       99
        
       	userRepo := postgresRepo.NewUserRepository(db)

     

       95
       100
        
       	userService := users.NewUserService(userRepo, identityResolver, defaultPDS)

     

       96
       101
        
       

     

       102
       102
       +
       	communityRepo := postgresRepo.NewCommunityRepository(db)

     

       103
       103
       +
       

     

       104
       104
       +
       	// Initialize DID generator for communities

     

       105
       105
       +
       	// IS_DEV_ENV=true:  Generate did:plc:xxx without registering to PLC directory

     

       106
       106
       +
       	// IS_DEV_ENV=false: Generate did:plc:xxx and register with PLC_DIRECTORY_URL

     

       107
       107
       +
       	isDevEnv := os.Getenv("IS_DEV_ENV") == "true"

     

       108
       108
       +
       	plcDirectoryURL := os.Getenv("PLC_DIRECTORY_URL")

     

       109
       109
       +
       	if plcDirectoryURL == "" {

     

       110
       110
       +
       		plcDirectoryURL = "https://plc.directory" // Default to Bluesky's PLC

     

       111
       111
       +
       	}

     

       112
       112
       +
       	didGenerator := did.NewGenerator(isDevEnv, plcDirectoryURL)

     

       113
       113
       +
       	log.Printf("DID generator initialized (dev_mode=%v, plc_url=%s)", isDevEnv, plcDirectoryURL)

     

       114
       114
       +
       

     

       115
       115
       +
       	instanceDID := os.Getenv("INSTANCE_DID")

     

       116
       116
       +
       	if instanceDID == "" {

     

       117
       117
       +
       		instanceDID = "did:web:coves.local" // Default for development

     

       118
       118
       +
       	}

     

       119
       119
       +
       	communityService := communities.NewCommunityService(communityRepo, didGenerator, defaultPDS, instanceDID)

     

       120
       120
       +
       

     

       121
       121
       +
       	// Authenticate Coves instance with PDS to enable community record writes

     

       122
       122
       +
       	// The instance needs a PDS account to write community records it owns

     

       123
       123
       +
       	pdsHandle := os.Getenv("PDS_INSTANCE_HANDLE")

     

       124
       124
       +
       	pdsPassword := os.Getenv("PDS_INSTANCE_PASSWORD")

     

       125
       125
       +
       	if pdsHandle != "" && pdsPassword != "" {

     

       126
       126
       +
       		log.Printf("Authenticating Coves instance (%s) with PDS...", instanceDID)

     

       127
       127
       +
       		accessToken, err := authenticateWithPDS(defaultPDS, pdsHandle, pdsPassword)

     

       128
       128
       +
       		if err != nil {

     

       129
       129
       +
       			log.Printf("Warning: Failed to authenticate with PDS: %v", err)

     

       130
       130
       +
       			log.Println("Community creation will fail until PDS authentication is configured")

     

       131
       131
       +
       		} else {

     

       132
       132
       +
       			if svc, ok := communityService.(interface{ SetPDSAccessToken(string) }); ok {

     

       133
       133
       +
       				svc.SetPDSAccessToken(accessToken)

     

       134
       134
       +
       				log.Println("✓ Coves instance authenticated with PDS")

     

       135
       135
       +
       			}

     

       136
       136
       +
       		}

     

       137
       137
       +
       	} else {

     

       138
       138
       +
       		log.Println("Note: PDS_INSTANCE_HANDLE and PDS_INSTANCE_PASSWORD not set")

     

       139
       139
       +
       		log.Println("Community creation via write-forward is disabled")

     

       140
       140
       +
       	}

     

       141
       141
       +
       

     

       97
       142
        
       	// Start Jetstream consumer for read-forward user indexing

     

       98
       143
        
       	jetstreamURL := os.Getenv("JETSTREAM_URL")

     

       99
       144
        
       	if jetstreamURL == "" {

     
···

       110
       155
        
       		}

     

       111
       156
        
       	}()

     

       112
       157
        
       

     

       113
       113
       -
       	log.Printf("Started Jetstream consumer: %s", jetstreamURL)

     

       158
       158
       +
       	log.Printf("Started Jetstream user consumer: %s", jetstreamURL)

     

       159
       159
       +
       

     

       160
       160
       +
       	// Note: Community indexing happens through the same Jetstream firehose

     

       161
       161
       +
       	// The CommunityEventConsumer is used by handlers when processing community-related events

     

       162
       162
       +
       	// For now, community records are created via write-forward to PDS, then indexed when

     

       163
       163
       +
       	// they appear in the firehose. A dedicated consumer can be added later if needed.

     

       164
       164
       +
       	log.Println("Community event consumer initialized (processes events from firehose)")

     

       114
       165
        
       

     

       115
       166
        
       	// Start OAuth cleanup background job

     

       116
       167
        
       	go func() {

     
···

       156
       207
        
       

     

       157
       208
        
       	// Register XRPC routes

     

       158
       209
        
       	routes.RegisterUserRoutes(r, userService)

     

       210
       210
       +
       	routes.RegisterCommunityRoutes(r, communityService)

     

       211
       211
       +
       	log.Println("Community XRPC endpoints registered")

     

       159
       212
        
       

     

       160
       213
        
       	r.Get("/health", func(w http.ResponseWriter, r *http.Request) {

     

       161
       214
        
       		w.WriteHeader(http.StatusOK)

     
···

       171
       224
        
       	fmt.Printf("Default PDS: %s\n", defaultPDS)

     

       172
       225
        
       	log.Fatal(http.ListenAndServe(":"+port, r))

     

       173
       226
        
       }

     

       227
       227
       +
       

     

       228
       228
       +
       // authenticateWithPDS creates a session on the PDS and returns an access token

     

       229
       229
       +
       func authenticateWithPDS(pdsURL, handle, password string) (string, error) {

     

       230
       230
       +
       	type CreateSessionRequest struct {

     

       231
       231
       +
       		Identifier string `json:"identifier"`

     

       232
       232
       +
       		Password   string `json:"password"`

     

       233
       233
       +
       	}

     

       234
       234
       +
       

     

       235
       235
       +
       	type CreateSessionResponse struct {

     

       236
       236
       +
       		DID       string `json:"did"`

     

       237
       237
       +
       		Handle    string `json:"handle"`

     

       238
       238
       +
       		AccessJwt string `json:"accessJwt"`

     

       239
       239
       +
       	}

     

       240
       240
       +
       

     

       241
       241
       +
       	reqBody, err := json.Marshal(CreateSessionRequest{

     

       242
       242
       +
       		Identifier: handle,

     

       243
       243
       +
       		Password:   password,

     

       244
       244
       +
       	})

     

       245
       245
       +
       	if err != nil {

     

       246
       246
       +
       		return "", fmt.Errorf("failed to marshal request: %w", err)

     

       247
       247
       +
       	}

     

       248
       248
       +
       

     

       249
       249
       +
       	resp, err := http.Post(

     

       250
       250
       +
       		pdsURL+"/xrpc/com.atproto.server.createSession",

     

       251
       251
       +
       		"application/json",

     

       252
       252
       +
       		bytes.NewReader(reqBody),

     

       253
       253
       +
       	)

     

       254
       254
       +
       	if err != nil {

     

       255
       255
       +
       		return "", fmt.Errorf("failed to call PDS: %w", err)

     

       256
       256
       +
       	}

     

       257
       257
       +
       	defer resp.Body.Close()

     

       258
       258
       +
       

     

       259
       259
       +
       	if resp.StatusCode != http.StatusOK {

     

       260
       260
       +
       		body, _ := io.ReadAll(resp.Body)

     

       261
       261
       +
       		return "", fmt.Errorf("PDS returned status %d: %s", resp.StatusCode, string(body))

     

       262
       262
       +
       	}

     

       263
       263
       +
       

     

       264
       264
       +
       	var session CreateSessionResponse

     

       265
       265
       +
       	if err := json.NewDecoder(resp.Body).Decode(&session); err != nil {

     

       266
       266
       +
       		return "", fmt.Errorf("failed to decode response: %w", err)

     

       267
       267
       +
       	}

     

       268
       268
       +
       

     

       269
       269
       +
       	return session.AccessJwt, nil

     

       270
       270
       +
       }