A container registry that uses the AT Protocol for manifest storage and S3 for blob storage.
atcr.io
docker
container
atproto
go
add middleware logging to xprc requests in hold. add tangled profile creation
+516
-7
+4
cmd/hold/main.go
+4
cmd/hold/main.go
···
17
17
_ "github.com/distribution/distribution/v3/registry/storage/driver/s3-aws"
18
18
19
19
"github.com/go-chi/chi/v5"
20
+
"github.com/go-chi/chi/v5/middleware"
20
21
)
21
22
22
23
func main() {
···
91
92
92
93
// Setup HTTP routes with chi router
93
94
r := chi.NewRouter()
95
+
96
+
// Add logging middleware to log all HTTP requests
97
+
r.Use(middleware.Logger)
94
98
95
99
// Root page
96
100
r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+421
pkg/atproto/cbor_gen.go
+421
pkg/atproto/cbor_gen.go
···
612
612
613
613
return nil
614
614
}
615
+
func (t *TangledProfileRecord) MarshalCBOR(w io.Writer) error {
616
+
if t == nil {
617
+
_, err := w.Write(cbg.CborNull)
618
+
return err
619
+
}
620
+
621
+
cw := cbg.NewCborWriter(w)
622
+
623
+
if _, err := cw.Write([]byte{167}); err != nil {
624
+
return err
625
+
}
626
+
627
+
// t.Type (string) (string)
628
+
if len("$type") > 8192 {
629
+
return xerrors.Errorf("Value in field \"$type\" was too long")
630
+
}
631
+
632
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
633
+
return err
634
+
}
635
+
if _, err := cw.WriteString(string("$type")); err != nil {
636
+
return err
637
+
}
638
+
639
+
if len(t.Type) > 8192 {
640
+
return xerrors.Errorf("Value in field t.Type was too long")
641
+
}
642
+
643
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil {
644
+
return err
645
+
}
646
+
if _, err := cw.WriteString(string(t.Type)); err != nil {
647
+
return err
648
+
}
649
+
650
+
// t.Links ([]string) (slice)
651
+
if len("links") > 8192 {
652
+
return xerrors.Errorf("Value in field \"links\" was too long")
653
+
}
654
+
655
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("links"))); err != nil {
656
+
return err
657
+
}
658
+
if _, err := cw.WriteString(string("links")); err != nil {
659
+
return err
660
+
}
661
+
662
+
if len(t.Links) > 8192 {
663
+
return xerrors.Errorf("Slice value in field t.Links was too long")
664
+
}
665
+
666
+
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Links))); err != nil {
667
+
return err
668
+
}
669
+
for _, v := range t.Links {
670
+
if len(v) > 8192 {
671
+
return xerrors.Errorf("Value in field v was too long")
672
+
}
673
+
674
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
675
+
return err
676
+
}
677
+
if _, err := cw.WriteString(string(v)); err != nil {
678
+
return err
679
+
}
680
+
681
+
}
682
+
683
+
// t.Stats ([]string) (slice)
684
+
if len("stats") > 8192 {
685
+
return xerrors.Errorf("Value in field \"stats\" was too long")
686
+
}
687
+
688
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stats"))); err != nil {
689
+
return err
690
+
}
691
+
if _, err := cw.WriteString(string("stats")); err != nil {
692
+
return err
693
+
}
694
+
695
+
if len(t.Stats) > 8192 {
696
+
return xerrors.Errorf("Slice value in field t.Stats was too long")
697
+
}
698
+
699
+
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Stats))); err != nil {
700
+
return err
701
+
}
702
+
for _, v := range t.Stats {
703
+
if len(v) > 8192 {
704
+
return xerrors.Errorf("Value in field v was too long")
705
+
}
706
+
707
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
708
+
return err
709
+
}
710
+
if _, err := cw.WriteString(string(v)); err != nil {
711
+
return err
712
+
}
713
+
714
+
}
715
+
716
+
// t.Bluesky (bool) (bool)
717
+
if len("bluesky") > 8192 {
718
+
return xerrors.Errorf("Value in field \"bluesky\" was too long")
719
+
}
720
+
721
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bluesky"))); err != nil {
722
+
return err
723
+
}
724
+
if _, err := cw.WriteString(string("bluesky")); err != nil {
725
+
return err
726
+
}
727
+
728
+
if err := cbg.WriteBool(w, t.Bluesky); err != nil {
729
+
return err
730
+
}
731
+
732
+
// t.Location (string) (string)
733
+
if len("location") > 8192 {
734
+
return xerrors.Errorf("Value in field \"location\" was too long")
735
+
}
736
+
737
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil {
738
+
return err
739
+
}
740
+
if _, err := cw.WriteString(string("location")); err != nil {
741
+
return err
742
+
}
743
+
744
+
if len(t.Location) > 8192 {
745
+
return xerrors.Errorf("Value in field t.Location was too long")
746
+
}
747
+
748
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Location))); err != nil {
749
+
return err
750
+
}
751
+
if _, err := cw.WriteString(string(t.Location)); err != nil {
752
+
return err
753
+
}
754
+
755
+
// t.Description (string) (string)
756
+
if len("description") > 8192 {
757
+
return xerrors.Errorf("Value in field \"description\" was too long")
758
+
}
759
+
760
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
761
+
return err
762
+
}
763
+
if _, err := cw.WriteString(string("description")); err != nil {
764
+
return err
765
+
}
766
+
767
+
if len(t.Description) > 8192 {
768
+
return xerrors.Errorf("Value in field t.Description was too long")
769
+
}
770
+
771
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
772
+
return err
773
+
}
774
+
if _, err := cw.WriteString(string(t.Description)); err != nil {
775
+
return err
776
+
}
777
+
778
+
// t.PinnedRepositories ([]string) (slice)
779
+
if len("pinnedRepositories") > 8192 {
780
+
return xerrors.Errorf("Value in field \"pinnedRepositories\" was too long")
781
+
}
782
+
783
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositories"))); err != nil {
784
+
return err
785
+
}
786
+
if _, err := cw.WriteString(string("pinnedRepositories")); err != nil {
787
+
return err
788
+
}
789
+
790
+
if len(t.PinnedRepositories) > 8192 {
791
+
return xerrors.Errorf("Slice value in field t.PinnedRepositories was too long")
792
+
}
793
+
794
+
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositories))); err != nil {
795
+
return err
796
+
}
797
+
for _, v := range t.PinnedRepositories {
798
+
if len(v) > 8192 {
799
+
return xerrors.Errorf("Value in field v was too long")
800
+
}
801
+
802
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
803
+
return err
804
+
}
805
+
if _, err := cw.WriteString(string(v)); err != nil {
806
+
return err
807
+
}
808
+
809
+
}
810
+
return nil
811
+
}
812
+
813
+
func (t *TangledProfileRecord) UnmarshalCBOR(r io.Reader) (err error) {
814
+
*t = TangledProfileRecord{}
815
+
816
+
cr := cbg.NewCborReader(r)
817
+
818
+
maj, extra, err := cr.ReadHeader()
819
+
if err != nil {
820
+
return err
821
+
}
822
+
defer func() {
823
+
if err == io.EOF {
824
+
err = io.ErrUnexpectedEOF
825
+
}
826
+
}()
827
+
828
+
if maj != cbg.MajMap {
829
+
return fmt.Errorf("cbor input should be of type map")
830
+
}
831
+
832
+
if extra > cbg.MaxLength {
833
+
return fmt.Errorf("TangledProfileRecord: map struct too large (%d)", extra)
834
+
}
835
+
836
+
n := extra
837
+
838
+
nameBuf := make([]byte, 18)
839
+
for i := uint64(0); i < n; i++ {
840
+
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192)
841
+
if err != nil {
842
+
return err
843
+
}
844
+
845
+
if !ok {
846
+
// Field doesn't exist on this type, so ignore it
847
+
if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
848
+
return err
849
+
}
850
+
continue
851
+
}
852
+
853
+
switch string(nameBuf[:nameLen]) {
854
+
// t.Type (string) (string)
855
+
case "$type":
856
+
857
+
{
858
+
sval, err := cbg.ReadStringWithMax(cr, 8192)
859
+
if err != nil {
860
+
return err
861
+
}
862
+
863
+
t.Type = string(sval)
864
+
}
865
+
// t.Links ([]string) (slice)
866
+
case "links":
867
+
868
+
maj, extra, err = cr.ReadHeader()
869
+
if err != nil {
870
+
return err
871
+
}
872
+
873
+
if extra > 8192 {
874
+
return fmt.Errorf("t.Links: array too large (%d)", extra)
875
+
}
876
+
877
+
if maj != cbg.MajArray {
878
+
return fmt.Errorf("expected cbor array")
879
+
}
880
+
881
+
if extra > 0 {
882
+
t.Links = make([]string, extra)
883
+
}
884
+
885
+
for i := 0; i < int(extra); i++ {
886
+
{
887
+
var maj byte
888
+
var extra uint64
889
+
var err error
890
+
_ = maj
891
+
_ = extra
892
+
_ = err
893
+
894
+
{
895
+
sval, err := cbg.ReadStringWithMax(cr, 8192)
896
+
if err != nil {
897
+
return err
898
+
}
899
+
900
+
t.Links[i] = string(sval)
901
+
}
902
+
903
+
}
904
+
}
905
+
// t.Stats ([]string) (slice)
906
+
case "stats":
907
+
908
+
maj, extra, err = cr.ReadHeader()
909
+
if err != nil {
910
+
return err
911
+
}
912
+
913
+
if extra > 8192 {
914
+
return fmt.Errorf("t.Stats: array too large (%d)", extra)
915
+
}
916
+
917
+
if maj != cbg.MajArray {
918
+
return fmt.Errorf("expected cbor array")
919
+
}
920
+
921
+
if extra > 0 {
922
+
t.Stats = make([]string, extra)
923
+
}
924
+
925
+
for i := 0; i < int(extra); i++ {
926
+
{
927
+
var maj byte
928
+
var extra uint64
929
+
var err error
930
+
_ = maj
931
+
_ = extra
932
+
_ = err
933
+
934
+
{
935
+
sval, err := cbg.ReadStringWithMax(cr, 8192)
936
+
if err != nil {
937
+
return err
938
+
}
939
+
940
+
t.Stats[i] = string(sval)
941
+
}
942
+
943
+
}
944
+
}
945
+
// t.Bluesky (bool) (bool)
946
+
case "bluesky":
947
+
948
+
maj, extra, err = cr.ReadHeader()
949
+
if err != nil {
950
+
return err
951
+
}
952
+
if maj != cbg.MajOther {
953
+
return fmt.Errorf("booleans must be major type 7")
954
+
}
955
+
switch extra {
956
+
case 20:
957
+
t.Bluesky = false
958
+
case 21:
959
+
t.Bluesky = true
960
+
default:
961
+
return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
962
+
}
963
+
// t.Location (string) (string)
964
+
case "location":
965
+
966
+
{
967
+
sval, err := cbg.ReadStringWithMax(cr, 8192)
968
+
if err != nil {
969
+
return err
970
+
}
971
+
972
+
t.Location = string(sval)
973
+
}
974
+
// t.Description (string) (string)
975
+
case "description":
976
+
977
+
{
978
+
sval, err := cbg.ReadStringWithMax(cr, 8192)
979
+
if err != nil {
980
+
return err
981
+
}
982
+
983
+
t.Description = string(sval)
984
+
}
985
+
// t.PinnedRepositories ([]string) (slice)
986
+
case "pinnedRepositories":
987
+
988
+
maj, extra, err = cr.ReadHeader()
989
+
if err != nil {
990
+
return err
991
+
}
992
+
993
+
if extra > 8192 {
994
+
return fmt.Errorf("t.PinnedRepositories: array too large (%d)", extra)
995
+
}
996
+
997
+
if maj != cbg.MajArray {
998
+
return fmt.Errorf("expected cbor array")
999
+
}
1000
+
1001
+
if extra > 0 {
1002
+
t.PinnedRepositories = make([]string, extra)
1003
+
}
1004
+
1005
+
for i := 0; i < int(extra); i++ {
1006
+
{
1007
+
var maj byte
1008
+
var extra uint64
1009
+
var err error
1010
+
_ = maj
1011
+
_ = extra
1012
+
_ = err
1013
+
1014
+
{
1015
+
sval, err := cbg.ReadStringWithMax(cr, 8192)
1016
+
if err != nil {
1017
+
return err
1018
+
}
1019
+
1020
+
t.PinnedRepositories[i] = string(sval)
1021
+
}
1022
+
1023
+
}
1024
+
}
1025
+
1026
+
default:
1027
+
// Field doesn't exist on this type, so ignore it
1028
+
if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1029
+
return err
1030
+
}
1031
+
}
1032
+
}
1033
+
1034
+
return nil
1035
+
}
+2
-1
pkg/atproto/generate.go
+2
-1
pkg/atproto/generate.go
···
25
25
)
26
26
27
27
func main() {
28
-
// Generate map-style encoders for CrewRecord and CaptainRecord
28
+
// Generate map-style encoders for CrewRecord, CaptainRecord, and TangledProfileRecord
29
29
if err := cbg.WriteMapEncodersToFile("cbor_gen.go", "atproto",
30
30
atproto.CrewRecord{},
31
31
atproto.CaptainRecord{},
32
+
atproto.TangledProfileRecord{},
32
33
); err != nil {
33
34
fmt.Printf("Failed to generate CBOR encoders: %v\n", err)
34
35
os.Exit(1)
+18
pkg/atproto/lexicon.go
+18
pkg/atproto/lexicon.go
···
34
34
// Note: Uses same collection name as HoldCrewCollection but stored in different PDS (hold's PDS vs owner's PDS)
35
35
CrewCollection = "io.atcr.hold.crew"
36
36
37
+
// TangledProfileCollection is the collection name for tangled profiles
38
+
// Stored in hold's embedded PDS (singleton record at rkey "self")
39
+
TangledProfileCollection = "sh.tangled.actor.profile"
40
+
37
41
// SailorProfileCollection is the collection name for user profiles
38
42
SailorProfileCollection = "io.atcr.sailor.profile"
39
43
···
515
519
Permissions []string `json:"permissions" cborgen:"permissions"`
516
520
AddedAt string `json:"addedAt" cborgen:"addedAt"` // RFC3339 timestamp
517
521
}
522
+
523
+
// TangledProfileRecord represents a Tangled profile for the hold
524
+
// Collection: sh.tangled.actor.profile (singleton record at rkey "self")
525
+
// Stored in the hold's embedded PDS
526
+
// Uses CBOR encoding for efficient storage in hold's carstore
527
+
type TangledProfileRecord struct {
528
+
Type string `json:"$type" cborgen:"$type"`
529
+
Links []string `json:"links" cborgen:"links"`
530
+
Stats []string `json:"stats" cborgen:"stats"`
531
+
Bluesky bool `json:"bluesky" cborgen:"bluesky"`
532
+
Location string `json:"location" cborgen:"location"`
533
+
Description string `json:"description" cborgen:"description"`
534
+
PinnedRepositories []string `json:"pinnedRepositories" cborgen:"pinnedRepositories"`
535
+
}
+48
pkg/hold/pds/profile.go
+48
pkg/hold/pds/profile.go
···
9
9
"net/http"
10
10
"time"
11
11
12
+
"atcr.io/pkg/atproto"
12
13
bsky "github.com/bluesky-social/indigo/api/bsky"
13
14
lexutil "github.com/bluesky-social/indigo/lex/util"
14
15
"github.com/distribution/distribution/v3/registry/storage/driver"
···
22
23
23
24
// ProfileCollection is the collection name for Bluesky actor profiles
24
25
ProfileCollection = "app.bsky.actor.profile"
26
+
27
+
// TangledProfileRkey is the fixed rkey for the tangled profile record (singleton)
28
+
TangledProfileRkey = "self"
29
+
30
+
// TangledProfileCollection is the collection name for Tangled actor profiles
31
+
TangledProfileCollection = "sh.tangled.actor.profile"
25
32
)
26
33
27
34
// downloadImage downloads an image from a URL and returns the data and content type
···
172
179
173
180
return recordCID, profileRecord, nil
174
181
}
182
+
183
+
// CreateTangledProfileRecord creates the sh.tangled.actor.profile record for the hold
184
+
// This will FAIL if the tangled profile record already exists.
185
+
func (p *HoldPDS) CreateTangledProfileRecord(ctx context.Context, links []string, description string) (cid.Cid, error) {
186
+
// Create tangled profile struct
187
+
profile := &atproto.TangledProfileRecord{
188
+
Type: atproto.TangledProfileCollection,
189
+
Links: links,
190
+
Stats: []string{}, // Empty for now
191
+
Bluesky: true,
192
+
Location: "",
193
+
Description: description,
194
+
PinnedRepositories: []string{}, // Empty for now
195
+
}
196
+
197
+
// Use repomgr.PutRecord - creates with explicit rkey, fails if already exists
198
+
recordPath, recordCID, err := p.repomgr.PutRecord(ctx, p.uid, TangledProfileCollection, TangledProfileRkey, profile)
199
+
if err != nil {
200
+
return cid.Undef, fmt.Errorf("failed to create tangled profile record: %w", err)
201
+
}
202
+
203
+
fmt.Printf("Created tangled profile record at %s, cid: %s\n", recordPath, recordCID)
204
+
return recordCID, nil
205
+
}
206
+
207
+
// GetTangledProfileRecord retrieves the sh.tangled.actor.profile record
208
+
func (p *HoldPDS) GetTangledProfileRecord(ctx context.Context) (cid.Cid, *atproto.TangledProfileRecord, error) {
209
+
// Use repomgr.GetRecord
210
+
recordCID, val, err := p.repomgr.GetRecord(ctx, p.uid, TangledProfileCollection, TangledProfileRkey, cid.Undef)
211
+
if err != nil {
212
+
return cid.Undef, nil, fmt.Errorf("failed to get tangled profile record: %w", err)
213
+
}
214
+
215
+
// Type assert to TangledProfileRecord
216
+
profileRecord, ok := val.(*atproto.TangledProfileRecord)
217
+
if !ok {
218
+
return cid.Undef, nil, fmt.Errorf("unexpected type for tangled profile record: %T", val)
219
+
}
220
+
221
+
return recordCID, profileRecord, nil
222
+
}
+23
-6
pkg/hold/pds/server.go
+23
-6
pkg/hold/pds/server.go
···
20
20
// init registers our custom ATProto types with indigo's lexutil type registry
21
21
// This allows repomgr.GetRecord to automatically unmarshal our types
22
22
func init() {
23
-
// Register captain and crew record types
23
+
// Register captain, crew, and tangled profile record types
24
24
// These must match the $type field in the records
25
25
lexutil.RegisterType(atproto.CaptainCollection, &atproto.CaptainRecord{})
26
26
lexutil.RegisterType(atproto.CrewCollection, &atproto.CrewRecord{})
27
+
lexutil.RegisterType(atproto.TangledProfileCollection, &atproto.TangledProfileRecord{})
27
28
}
28
29
29
30
// HoldPDS is a minimal ATProto PDS implementation for a hold service
···
157
158
fmt.Printf("✅ Added %s as hold admin\n", ownerDID)
158
159
}
159
160
160
-
// Create profile record (idempotent - check if exists first)
161
+
// Create Bluesky profile record (idempotent - check if exists first)
161
162
// This runs even if captain exists (for existing holds being upgraded)
162
163
// Skip if no storage driver (e.g., in tests)
163
164
if storageDriver != nil {
164
165
_, _, err = p.GetProfileRecord(ctx)
165
166
if err != nil {
166
-
// Profile doesn't exist, create it
167
+
// Bluesky profile doesn't exist, create it
167
168
displayName := "Cargo Hold"
168
169
description := "ahoy from the cargo hold"
169
170
170
171
_, err = p.CreateProfileRecord(ctx, storageDriver, displayName, description, avatarURL)
171
172
if err != nil {
172
-
return fmt.Errorf("failed to create profile record: %w", err)
173
+
return fmt.Errorf("failed to create bluesky profile record: %w", err)
173
174
}
174
-
fmt.Printf("✅ Created profile record (displayName=%s)\n", displayName)
175
+
fmt.Printf("✅ Created Bluesky profile record (displayName=%s)\n", displayName)
175
176
} else {
176
-
fmt.Printf("✅ Profile record already exists, skipping\n")
177
+
fmt.Printf("✅ Bluesky profile record already exists, skipping\n")
178
+
}
179
+
180
+
// Create Tangled profile record (idempotent - check if exists first)
181
+
_, _, err = p.GetTangledProfileRecord(ctx)
182
+
if err != nil {
183
+
// Tangled profile doesn't exist, create it
184
+
description := "ahoy from the cargo hold"
185
+
links := []string{"https://atcr.io"}
186
+
187
+
_, err = p.CreateTangledProfileRecord(ctx, links, description)
188
+
if err != nil {
189
+
return fmt.Errorf("failed to create tangled profile record: %w", err)
190
+
}
191
+
fmt.Printf("✅ Created Tangled profile record\n")
192
+
} else {
193
+
fmt.Printf("✅ Tangled profile record already exists, skipping\n")
177
194
}
178
195
}
179
196