commit c2d4cdb55398881044d18ea582ebe997853823fe · veryroundbird.house/core

appview/config/config.go

···

       19
       19
        
       

     

       20
       20
        
       	// temporarily, to add users to default knot and spindle

     

       21
       21
        
       	AppPassword string `env:"APP_PASSWORD"`

     

       22
       22
       +
       

     

       23
       23
       +
       	// uhhhh this is because knot1 is under icy's did

     

       24
       24
       +
       	TmpAltAppPassword string `env:"ALT_APP_PASSWORD, required"`

     

       22
       25
        
       }

     

       23
       26
        
       

     

       24
       27
        
       type OAuthConfig struct {

+19 -14

appview/oauth/handler/handler.go

···

       354
       354
        
       }

     

       355
       355
        
       

     

       356
       356
        
       var (

     

       357
       357
       -
       	tangledHandle  = "tangled.sh"

     

       358
       358
       -
       	tangledDid     = "did:plc:wshs7t2adsemcrrd4snkeqli"

     

       357
       357
       +
       	tangledHandle = "tangled.sh"

     

       358
       358
       +
       	tangledDid    = "did:plc:wshs7t2adsemcrrd4snkeqli"

     

       359
       359
       +
       

     

       360
       360
       +
       	icyHandle = "icyphox.sh"

     

       361
       361
       +
       	icyDid    = "did:plc:hwevmowznbiukdf6uk5dwrrq"

     

       362
       362
       +
       

     

       359
       363
        
       	defaultSpindle = "spindle.tangled.sh"

     

       360
       364
        
       	defaultKnot    = "knot1.tangled.sh"

     

       361
       365
        
       )

     
···

       379
       383
        
       	}

     

       380
       384
        
       

     

       381
       385
        
       	log.Printf("adding %s to default spindle", did)

     

       382
       382
       -
       	session, err := o.createAppPasswordSession()

     

       386
       386
       +
       	session, err := o.createAppPasswordSession(o.config.Core.AppPassword, tangledHandle, tangledDid)

     

       383
       387
        
       	if err != nil {

     

       384
       388
        
       		log.Printf("failed to create session: %s", err)

     

       385
       389
        
       		return

     
···

       393
       397
        
       	}

     

       394
       398
        
       

     

       395
       399
        
       	if err := session.putRecord(record); err != nil {

     

       396
       396
       -
       		log.Printf("failed to add member to default knot: %s", err)

     

       400
       400
       +
       		log.Printf("failed to add member to default spindle: %s", err)

     

       397
       401
        
       		return

     

       398
       402
        
       	}

     

       399
       403
        
       

     
···

       416
       420
        
       	}

     

       417
       421
        
       

     

       418
       422
        
       	log.Printf("adding %s to default knot", did)

     

       419
       419
       -
       	session, err := o.createAppPasswordSession()

     

       423
       423
       +
       	session, err := o.createAppPasswordSession(o.config.Core.TmpAltAppPassword, icyHandle, icyDid)

     

       420
       424
        
       	if err != nil {

     

       421
       425
        
       		log.Printf("failed to create session: %s", err)

     

       422
       426
        
       		return

     
···

       441
       445
        
       type session struct {

     

       442
       446
        
       	AccessJwt   string `json:"accessJwt"`

     

       443
       447
        
       	PdsEndpoint string

     

       448
       448
       +
       	Did         string

     

       444
       449
        
       }

     

       445
       450
        
       

     

       446
       446
       -
       func (o *OAuthHandler) createAppPasswordSession() (*session, error) {

     

       447
       447
       -
       	appPassword := o.config.Core.AppPassword

     

       451
       451
       +
       func (o *OAuthHandler) createAppPasswordSession(appPassword, handle, did string) (*session, error) {

     

       448
       452
        
       	if appPassword == "" {

     

       449
       453
        
       		return nil, fmt.Errorf("no app password configured, skipping member addition")

     

       450
       454
        
       	}

     

       451
       455
        
       

     

       452
       452
       -
       	resolved, err := o.idResolver.ResolveIdent(context.Background(), tangledDid)

     

       456
       456
       +
       	resolved, err := o.idResolver.ResolveIdent(context.Background(), did)

     

       453
       457
        
       	if err != nil {

     

       454
       454
       -
       		return nil, fmt.Errorf("failed to resolve tangled.sh DID %s: %v", tangledDid, err)

     

       458
       458
       +
       		return nil, fmt.Errorf("failed to resolve tangled.sh DID %s: %v", did, err)

     

       455
       459
        
       	}

     

       456
       460
        
       

     

       457
       461
        
       	pdsEndpoint := resolved.PDSEndpoint()

     

       458
       462
        
       	if pdsEndpoint == "" {

     

       459
       459
       -
       		return nil, fmt.Errorf("no PDS endpoint found for tangled.sh DID %s", tangledDid)

     

       463
       463
       +
       		return nil, fmt.Errorf("no PDS endpoint found for tangled.sh DID %s", did)

     

       460
       464
        
       	}

     

       461
       465
        
       

     

       462
       466
        
       	sessionPayload := map[string]string{

     

       463
       463
       -
       		"identifier": tangledHandle,

     

       467
       467
       +
       		"identifier": handle,

     

       464
       468
        
       		"password":   appPassword,

     

       465
       469
        
       	}

     

       466
       470
        
       	sessionBytes, err := json.Marshal(sessionPayload)

     
···

       492
       496
        
       	}

     

       493
       497
        
       

     

       494
       498
        
       	session.PdsEndpoint = pdsEndpoint

     

       499
       499
       +
       	session.Did = did

     

       495
       500
        
       

     

       496
       501
        
       	return &session, nil

     

       497
       502
        
       }

     
···

       503
       508
        
       	}

     

       504
       509
        
       

     

       505
       510
        
       	payload := map[string]any{

     

       506
       506
       -
       		"repo":       tangledDid,

     

       511
       511
       +
       		"repo":       s.Did,

     

       507
       512
        
       		"collection": tangled.KnotMemberNSID,

     

       508
       513
        
       		"rkey":       tid.TID(),

     

       509
       514
        
       		"record":     json.RawMessage(recordBytes),

     
···

       526
       531
        
       	client := &http.Client{Timeout: 30 * time.Second}

     

       527
       532
        
       	resp, err := client.Do(req)

     

       528
       533
        
       	if err != nil {

     

       529
       529
       -
       		return fmt.Errorf("failed to add user to default Knot: %w", err)

     

       534
       534
       +
       		return fmt.Errorf("failed to add user to default service: %w", err)

     

       530
       535
        
       	}

     

       531
       536
        
       	defer resp.Body.Close()

     

       532
       537
        
       

     

       533
       538
        
       	if resp.StatusCode != http.StatusOK {

     

       534
       534
       -
       		return fmt.Errorf("failed to add user to default Knot: HTTP %d", resp.StatusCode)

     

       539
       539
       +
       		return fmt.Errorf("failed to add user to default service: HTTP %d", resp.StatusCode)

     

       535
       540
        
       	}

     

       536
       541
        
       

     

       537
       542
        
       	return nil