···

       
19
       
 
       


     

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

     

       
21
       
 
       
	AppPassword string `env:"APP_PASSWORD"`

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
22
       
 
       
}

     

       
23
       
 
       


     

       
24
       
 
       
type OAuthConfig struct {

     

···

       
19
       
 
       


     

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

     

       
21
       
 
       
	AppPassword string `env:"APP_PASSWORD"`

     

       
22
       
+
       


     

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

     

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

     

       
25
       
 
       
}

     

       
26
       
 
       


     

       
27
       
 
       
type OAuthConfig struct {

     

···

       
354
       
 
       
}

     

       
355
       
 
       


     

       
356
       
 
       
var (

     

       
357
       
-
       
	tangledHandle  = "tangled.sh"

     

       
358
       
-
       
	tangledDid     = "did:plc:wshs7t2adsemcrrd4snkeqli"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
359
       
 
       
	defaultSpindle = "spindle.tangled.sh"

     

       
360
       
 
       
	defaultKnot    = "knot1.tangled.sh"

     

       
361
       
 
       
)

     
···

       
379
       
 
       
	}

     

       
380
       
 
       


     

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

     

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

     

       
383
       
 
       
	if err != nil {

     

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

     

       
385
       
 
       
		return

     
···

       
393
       
 
       
	}

     

       
394
       
 
       


     

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

     

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

     

       
397
       
 
       
		return

     

       
398
       
 
       
	}

     

       
399
       
 
       


     
···

       
416
       
 
       
	}

     

       
417
       
 
       


     

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

     

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

     

       
420
       
 
       
	if err != nil {

     

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

     

       
422
       
 
       
		return

     
···

       
441
       
 
       
type session struct {

     

       
442
       
 
       
	AccessJwt   string `json:"accessJwt"`

     

       
443
       
 
       
	PdsEndpoint string

     

       
0
       
 
       

     

       
444
       
 
       
}

     

       
445
       
 
       


     

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

     

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

     

       
448
       
 
       
	if appPassword == "" {

     

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

     

       
450
       
 
       
	}

     

       
451
       
 
       


     

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

     

       
453
       
 
       
	if err != nil {

     

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

     

       
455
       
 
       
	}

     

       
456
       
 
       


     

       
457
       
 
       
	pdsEndpoint := resolved.PDSEndpoint()

     

       
458
       
 
       
	if pdsEndpoint == "" {

     

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

     

       
460
       
 
       
	}

     

       
461
       
 
       


     

       
462
       
 
       
	sessionPayload := map[string]string{

     

       
463
       
-
       
		"identifier": tangledHandle,

     

       
464
       
 
       
		"password":   appPassword,

     

       
465
       
 
       
	}

     

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

     
···

       
492
       
 
       
	}

     

       
493
       
 
       


     

       
494
       
 
       
	session.PdsEndpoint = pdsEndpoint

     

       
0
       
 
       

     

       
495
       
 
       


     

       
496
       
 
       
	return &session, nil

     

       
497
       
 
       
}

     
···

       
503
       
 
       
	}

     

       
504
       
 
       


     

       
505
       
 
       
	payload := map[string]any{

     

       
506
       
-
       
		"repo":       tangledDid,

     

       
507
       
 
       
		"collection": tangled.KnotMemberNSID,

     

       
508
       
 
       
		"rkey":       tid.TID(),

     

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

     
···

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

     

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

     

       
528
       
 
       
	if err != nil {

     

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

     

       
530
       
 
       
	}

     

       
531
       
 
       
	defer resp.Body.Close()

     

       
532
       
 
       


     

       
533
       
 
       
	if resp.StatusCode != http.StatusOK {

     

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

     

       
535
       
 
       
	}

     

       
536
       
 
       


     

       
537
       
 
       
	return nil

     

···

       
354
       
 
       
}

     

       
355
       
 
       


     

       
356
       
 
       
var (

     

       
357
       
+
       
	tangledHandle = "tangled.sh"

     

       
358
       
+
       
	tangledDid    = "did:plc:wshs7t2adsemcrrd4snkeqli"

     

       
359
       
+
       


     

       
360
       
+
       
	icyHandle = "icyphox.sh"

     

       
361
       
+
       
	icyDid    = "did:plc:hwevmowznbiukdf6uk5dwrrq"

     

       
362
       
+
       


     

       
363
       
 
       
	defaultSpindle = "spindle.tangled.sh"

     

       
364
       
 
       
	defaultKnot    = "knot1.tangled.sh"

     

       
365
       
 
       
)

     
···

       
383
       
 
       
	}

     

       
384
       
 
       


     

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

     

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

     

       
387
       
 
       
	if err != nil {

     

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

     

       
389
       
 
       
		return

     
···

       
397
       
 
       
	}

     

       
398
       
 
       


     

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

     

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

     

       
401
       
 
       
		return

     

       
402
       
 
       
	}

     

       
403
       
 
       


     
···

       
420
       
 
       
	}

     

       
421
       
 
       


     

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

     

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

     

       
424
       
 
       
	if err != nil {

     

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

     

       
426
       
 
       
		return

     
···

       
445
       
 
       
type session struct {

     

       
446
       
 
       
	AccessJwt   string `json:"accessJwt"`

     

       
447
       
 
       
	PdsEndpoint string

     

       
448
       
+
       
	Did         string

     

       
449
       
 
       
}

     

       
450
       
 
       


     

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

     

       
0
       
 
       

     

       
452
       
 
       
	if appPassword == "" {

     

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

     

       
454
       
 
       
	}

     

       
455
       
 
       


     

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

     

       
457
       
 
       
	if err != nil {

     

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

     

       
459
       
 
       
	}

     

       
460
       
 
       


     

       
461
       
 
       
	pdsEndpoint := resolved.PDSEndpoint()

     

       
462
       
 
       
	if pdsEndpoint == "" {

     

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

     

       
464
       
 
       
	}

     

       
465
       
 
       


     

       
466
       
 
       
	sessionPayload := map[string]string{

     

       
467
       
+
       
		"identifier": handle,

     

       
468
       
 
       
		"password":   appPassword,

     

       
469
       
 
       
	}

     

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

     
···

       
496
       
 
       
	}

     

       
497
       
 
       


     

       
498
       
 
       
	session.PdsEndpoint = pdsEndpoint

     

       
499
       
+
       
	session.Did = did

     

       
500
       
 
       


     

       
501
       
 
       
	return &session, nil

     

       
502
       
 
       
}

     
···

       
508
       
 
       
	}

     

       
509
       
 
       


     

       
510
       
 
       
	payload := map[string]any{

     

       
511
       
+
       
		"repo":       s.Did,

     

       
512
       
 
       
		"collection": tangled.KnotMemberNSID,

     

       
513
       
 
       
		"rkey":       tid.TID(),

     

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

     
···

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

     

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

     

       
533
       
 
       
	if err != nil {

     

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

     

       
535
       
 
       
	}

     

       
536
       
 
       
	defer resp.Body.Close()

     

       
537
       
 
       


     

       
538
       
 
       
	if resp.StatusCode != http.StatusOK {

     

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

     

       
540
       
 
       
	}

     

       
541
       
 
       


     

       
542
       
 
       
	return nil