+1493

api/tangled/cbor_gen.go

reviewed

··· 3844 3844 3845 3845 return nil 3846 3846 } 3847 3847 + func (t *PijulRefUpdate) MarshalCBOR(w io.Writer) error { 3848 3848 + if t == nil { 3849 3849 + _, err := w.Write(cbg.CborNull) 3850 3850 + return err 3851 3851 + } 3852 3852 + 3853 3853 + cw := cbg.NewCborWriter(w) 3854 3854 + fieldCount := 8 3855 3855 + 3856 3856 + if t.Languages == nil { 3857 3857 + fieldCount-- 3858 3858 + } 3859 3859 + 3860 3860 + if t.OldState == nil { 3861 3861 + fieldCount-- 3862 3862 + } 3863 3863 + 3864 3864 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 3865 3865 + return err 3866 3866 + } 3867 3867 + 3868 3868 + // t.Repo (string) (string) 3869 3869 + if len("repo") > 1000000 { 3870 3870 + return xerrors.Errorf("Value in field \"repo\" was too long") 3871 3871 + } 3872 3872 + 3873 3873 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 3874 3874 + return err 3875 3875 + } 3876 3876 + if _, err := cw.WriteString(string("repo")); err != nil { 3877 3877 + return err 3878 3878 + } 3879 3879 + 3880 3880 + if len(t.Repo) > 1000000 { 3881 3881 + return xerrors.Errorf("Value in field t.Repo was too long") 3882 3882 + } 3883 3883 + 3884 3884 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 3885 3885 + return err 3886 3886 + } 3887 3887 + if _, err := cw.WriteString(string(t.Repo)); err != nil { 3888 3888 + return err 3889 3889 + } 3890 3890 + 3891 3891 + // t.CommitterDid (string) (string) 3892 3892 + if len("committerDid") > 1000000 { 3893 3893 + return xerrors.Errorf("Value in field \"committerDid\" was too long") 3894 3894 + } 3895 3895 + 3896 3896 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil { 3897 3897 + return err 3898 3898 + } 3899 3899 + if _, err := cw.WriteString(string("committerDid")); err != nil { 3900 3900 + return err 3901 3901 + } 3902 3902 + 3903 3903 + if len(t.CommitterDid) > 1000000 { 3904 3904 + return xerrors.Errorf("Value in field t.CommitterDid was too long") 3905 3905 + } 3906 3906 + 3907 3907 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil { 3908 3908 + return err 3909 3909 + } 3910 3910 + if _, err := cw.WriteString(string(t.CommitterDid)); err != nil { 3911 3911 + return err 3912 3912 + } 3913 3913 + 3914 3914 + // t.LexiconTypeID (string) (string) 3915 3915 + if len("$type") > 1000000 { 3916 3916 + return xerrors.Errorf("Value in field \"$type\" was too long") 3917 3917 + } 3918 3918 + 3919 3919 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 3920 3920 + return err 3921 3921 + } 3922 3922 + if _, err := cw.WriteString(string("$type")); err != nil { 3923 3923 + return err 3924 3924 + } 3925 3925 + 3926 3926 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pijul.refUpdate"))); err != nil { 3927 3927 + return err 3928 3928 + } 3929 3929 + if _, err := cw.WriteString(string("sh.tangled.pijul.refUpdate")); err != nil { 3930 3930 + return err 3931 3931 + } 3932 3932 + 3933 3933 + // t.Changes ([]string) (slice) 3934 3934 + if len("changes") > 1000000 { 3935 3935 + return xerrors.Errorf("Value in field \"changes\" was too long") 3936 3936 + } 3937 3937 + 3938 3938 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("changes"))); err != nil { 3939 3939 + return err 3940 3940 + } 3941 3941 + if _, err := cw.WriteString(string("changes")); err != nil { 3942 3942 + return err 3943 3943 + } 3944 3944 + 3945 3945 + if len(t.Changes) > 8192 { 3946 3946 + return xerrors.Errorf("Slice value in field t.Changes was too long") 3947 3947 + } 3948 3948 + 3949 3949 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Changes))); err != nil { 3950 3950 + return err 3951 3951 + } 3952 3952 + for _, v := range t.Changes { 3953 3953 + if len(v) > 1000000 { 3954 3954 + return xerrors.Errorf("Value in field v was too long") 3955 3955 + } 3956 3956 + 3957 3957 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 3958 3958 + return err 3959 3959 + } 3960 3960 + if _, err := cw.WriteString(string(v)); err != nil { 3961 3961 + return err 3962 3962 + } 3963 3963 + 3964 3964 + } 3965 3965 + 3966 3966 + // t.Channel (string) (string) 3967 3967 + if len("channel") > 1000000 { 3968 3968 + return xerrors.Errorf("Value in field \"channel\" was too long") 3969 3969 + } 3970 3970 + 3971 3971 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("channel"))); err != nil { 3972 3972 + return err 3973 3973 + } 3974 3974 + if _, err := cw.WriteString(string("channel")); err != nil { 3975 3975 + return err 3976 3976 + } 3977 3977 + 3978 3978 + if len(t.Channel) > 1000000 { 3979 3979 + return xerrors.Errorf("Value in field t.Channel was too long") 3980 3980 + } 3981 3981 + 3982 3982 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Channel))); err != nil { 3983 3983 + return err 3984 3984 + } 3985 3985 + if _, err := cw.WriteString(string(t.Channel)); err != nil { 3986 3986 + return err 3987 3987 + } 3988 3988 + 3989 3989 + // t.NewState (string) (string) 3990 3990 + if len("newState") > 1000000 { 3991 3991 + return xerrors.Errorf("Value in field \"newState\" was too long") 3992 3992 + } 3993 3993 + 3994 3994 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newState"))); err != nil { 3995 3995 + return err 3996 3996 + } 3997 3997 + if _, err := cw.WriteString(string("newState")); err != nil { 3998 3998 + return err 3999 3999 + } 4000 4000 + 4001 4001 + if len(t.NewState) > 1000000 { 4002 4002 + return xerrors.Errorf("Value in field t.NewState was too long") 4003 4003 + } 4004 4004 + 4005 4005 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewState))); err != nil { 4006 4006 + return err 4007 4007 + } 4008 4008 + if _, err := cw.WriteString(string(t.NewState)); err != nil { 4009 4009 + return err 4010 4010 + } 4011 4011 + 4012 4012 + // t.OldState (string) (string) 4013 4013 + if t.OldState != nil { 4014 4014 + 4015 4015 + if len("oldState") > 1000000 { 4016 4016 + return xerrors.Errorf("Value in field \"oldState\" was too long") 4017 4017 + } 4018 4018 + 4019 4019 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldState"))); err != nil { 4020 4020 + return err 4021 4021 + } 4022 4022 + if _, err := cw.WriteString(string("oldState")); err != nil { 4023 4023 + return err 4024 4024 + } 4025 4025 + 4026 4026 + if t.OldState == nil { 4027 4027 + if _, err := cw.Write(cbg.CborNull); err != nil { 4028 4028 + return err 4029 4029 + } 4030 4030 + } else { 4031 4031 + if len(*t.OldState) > 1000000 { 4032 4032 + return xerrors.Errorf("Value in field t.OldState was too long") 4033 4033 + } 4034 4034 + 4035 4035 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.OldState))); err != nil { 4036 4036 + return err 4037 4037 + } 4038 4038 + if _, err := cw.WriteString(string(*t.OldState)); err != nil { 4039 4039 + return err 4040 4040 + } 4041 4041 + } 4042 4042 + } 4043 4043 + 4044 4044 + // t.Languages (tangled.PijulRefUpdate_Languages) (struct) 4045 4045 + if t.Languages != nil { 4046 4046 + 4047 4047 + if len("languages") > 1000000 { 4048 4048 + return xerrors.Errorf("Value in field \"languages\" was too long") 4049 4049 + } 4050 4050 + 4051 4051 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("languages"))); err != nil { 4052 4052 + return err 4053 4053 + } 4054 4054 + if _, err := cw.WriteString(string("languages")); err != nil { 4055 4055 + return err 4056 4056 + } 4057 4057 + 4058 4058 + if err := t.Languages.MarshalCBOR(cw); err != nil { 4059 4059 + return err 4060 4060 + } 4061 4061 + } 4062 4062 + return nil 4063 4063 + } 4064 4064 + 4065 4065 + func (t *PijulRefUpdate) UnmarshalCBOR(r io.Reader) (err error) { 4066 4066 + *t = PijulRefUpdate{} 4067 4067 + 4068 4068 + cr := cbg.NewCborReader(r) 4069 4069 + 4070 4070 + maj, extra, err := cr.ReadHeader() 4071 4071 + if err != nil { 4072 4072 + return err 4073 4073 + } 4074 4074 + defer func() { 4075 4075 + if err == io.EOF { 4076 4076 + err = io.ErrUnexpectedEOF 4077 4077 + } 4078 4078 + }() 4079 4079 + 4080 4080 + if maj != cbg.MajMap { 4081 4081 + return fmt.Errorf("cbor input should be of type map") 4082 4082 + } 4083 4083 + 4084 4084 + if extra > cbg.MaxLength { 4085 4085 + return fmt.Errorf("PijulRefUpdate: map struct too large (%d)", extra) 4086 4086 + } 4087 4087 + 4088 4088 + n := extra 4089 4089 + 4090 4090 + nameBuf := make([]byte, 9) 4091 4091 + for i := uint64(0); i < n; i++ { 4092 4092 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4093 4093 + if err != nil { 4094 4094 + return err 4095 4095 + } 4096 4096 + 4097 4097 + if !ok { 4098 4098 + // Field doesn't exist on this type, so ignore it 4099 4099 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 4100 4100 + return err 4101 4101 + } 4102 4102 + continue 4103 4103 + } 4104 4104 + 4105 4105 + switch string(nameBuf[:nameLen]) { 4106 4106 + // t.Repo (string) (string) 4107 4107 + case "repo": 4108 4108 + 4109 4109 + { 4110 4110 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4111 4111 + if err != nil { 4112 4112 + return err 4113 4113 + } 4114 4114 + 4115 4115 + t.Repo = string(sval) 4116 4116 + } 4117 4117 + // t.LexiconTypeID (string) (string) 4118 4118 + case "$type": 4119 4119 + 4120 4120 + { 4121 4121 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4122 4122 + if err != nil { 4123 4123 + return err 4124 4124 + } 4125 4125 + 4126 4126 + t.LexiconTypeID = string(sval) 4127 4127 + } 4128 4128 + // t.Changes ([]string) (slice) 4129 4129 + case "changes": 4130 4130 + 4131 4131 + maj, extra, err = cr.ReadHeader() 4132 4132 + if err != nil { 4133 4133 + return err 4134 4134 + } 4135 4135 + 4136 4136 + if extra > 8192 { 4137 4137 + return fmt.Errorf("t.Changes: array too large (%d)", extra) 4138 4138 + } 4139 4139 + 4140 4140 + if maj != cbg.MajArray { 4141 4141 + return fmt.Errorf("expected cbor array") 4142 4142 + } 4143 4143 + 4144 4144 + if extra > 0 { 4145 4145 + t.Changes = make([]string, extra) 4146 4146 + } 4147 4147 + 4148 4148 + for i := 0; i < int(extra); i++ { 4149 4149 + { 4150 4150 + var maj byte 4151 4151 + var extra uint64 4152 4152 + var err error 4153 4153 + _ = maj 4154 4154 + _ = extra 4155 4155 + _ = err 4156 4156 + 4157 4157 + { 4158 4158 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4159 4159 + if err != nil { 4160 4160 + return err 4161 4161 + } 4162 4162 + 4163 4163 + t.Changes[i] = string(sval) 4164 4164 + } 4165 4165 + 4166 4166 + } 4167 4167 + } 4168 4168 + // t.Channel (string) (string) 4169 4169 + case "channel": 4170 4170 + 4171 4171 + { 4172 4172 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4173 4173 + if err != nil { 4174 4174 + return err 4175 4175 + } 4176 4176 + 4177 4177 + t.Channel = string(sval) 4178 4178 + } 4179 4179 + // t.CommitterDid (string) (string) 4180 4180 + case "committerDid": 4181 4181 + 4182 4182 + { 4183 4183 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4184 4184 + if err != nil { 4185 4185 + return err 4186 4186 + } 4187 4187 + 4188 4188 + t.CommitterDid = string(sval) 4189 4189 + } 4190 4190 + // t.NewState (string) (string) 4191 4191 + case "newState": 4192 4192 + 4193 4193 + { 4194 4194 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4195 4195 + if err != nil { 4196 4196 + return err 4197 4197 + } 4198 4198 + 4199 4199 + t.NewState = string(sval) 4200 4200 + } 4201 4201 + // t.OldState (string) (string) 4202 4202 + case "oldState": 4203 4203 + 4204 4204 + { 4205 4205 + b, err := cr.ReadByte() 4206 4206 + if err != nil { 4207 4207 + return err 4208 4208 + } 4209 4209 + if b != cbg.CborNull[0] { 4210 4210 + if err := cr.UnreadByte(); err != nil { 4211 4211 + return err 4212 4212 + } 4213 4213 + 4214 4214 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4215 4215 + if err != nil { 4216 4216 + return err 4217 4217 + } 4218 4218 + 4219 4219 + t.OldState = (*string)(&sval) 4220 4220 + } 4221 4221 + } 4222 4222 + // t.Languages (tangled.PijulRefUpdate_Languages) (struct) 4223 4223 + case "languages": 4224 4224 + 4225 4225 + { 4226 4226 + 4227 4227 + b, err := cr.ReadByte() 4228 4228 + if err != nil { 4229 4229 + return err 4230 4230 + } 4231 4231 + if b != cbg.CborNull[0] { 4232 4232 + if err := cr.UnreadByte(); err != nil { 4233 4233 + return err 4234 4234 + } 4235 4235 + t.Languages = new(PijulRefUpdate_Languages) 4236 4236 + if err := t.Languages.UnmarshalCBOR(cr); err != nil { 4237 4237 + return xerrors.Errorf("unmarshaling t.Languages pointer: %w", err) 4238 4238 + } 4239 4239 + } 4240 4240 + 4241 4241 + } 4242 4242 + 4243 4243 + default: 4244 4244 + // Field doesn't exist on this type, so ignore it 4245 4245 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 4246 4246 + return err 4247 4247 + } 4248 4248 + } 4249 4249 + } 4250 4250 + 4251 4251 + return nil 4252 4252 + } 3847 4253 func (t *Pipeline) MarshalCBOR(w io.Writer) error { 3848 4254 if t == nil { 3849 4255 _, err := w.Write(cbg.CborNull) ··· 7480 7886 } 7481 7887 7482 7888 t.CreatedAt = string(sval) 7889 7889 + } 7890 7890 + 7891 7891 + default: 7892 7892 + // Field doesn't exist on this type, so ignore it 7893 7893 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7894 7894 + return err 7895 7895 + } 7896 7896 + } 7897 7897 + } 7898 7898 + 7899 7899 + return nil 7900 7900 + } 7901 7901 + func (t *RepoDiscussion) MarshalCBOR(w io.Writer) error { 7902 7902 + if t == nil { 7903 7903 + _, err := w.Write(cbg.CborNull) 7904 7904 + return err 7905 7905 + } 7906 7906 + 7907 7907 + cw := cbg.NewCborWriter(w) 7908 7908 + fieldCount := 8 7909 7909 + 7910 7910 + if t.Body == nil { 7911 7911 + fieldCount-- 7912 7912 + } 7913 7913 + 7914 7914 + if t.Mentions == nil { 7915 7915 + fieldCount-- 7916 7916 + } 7917 7917 + 7918 7918 + if t.References == nil { 7919 7919 + fieldCount-- 7920 7920 + } 7921 7921 + 7922 7922 + if t.TargetChannel == nil { 7923 7923 + fieldCount-- 7924 7924 + } 7925 7925 + 7926 7926 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 7927 7927 + return err 7928 7928 + } 7929 7929 + 7930 7930 + // t.Body (string) (string) 7931 7931 + if t.Body != nil { 7932 7932 + 7933 7933 + if len("body") > 1000000 { 7934 7934 + return xerrors.Errorf("Value in field \"body\" was too long") 7935 7935 + } 7936 7936 + 7937 7937 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 7938 7938 + return err 7939 7939 + } 7940 7940 + if _, err := cw.WriteString(string("body")); err != nil { 7941 7941 + return err 7942 7942 + } 7943 7943 + 7944 7944 + if t.Body == nil { 7945 7945 + if _, err := cw.Write(cbg.CborNull); err != nil { 7946 7946 + return err 7947 7947 + } 7948 7948 + } else { 7949 7949 + if len(*t.Body) > 1000000 { 7950 7950 + return xerrors.Errorf("Value in field t.Body was too long") 7951 7951 + } 7952 7952 + 7953 7953 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil { 7954 7954 + return err 7955 7955 + } 7956 7956 + if _, err := cw.WriteString(string(*t.Body)); err != nil { 7957 7957 + return err 7958 7958 + } 7959 7959 + } 7960 7960 + } 7961 7961 + 7962 7962 + // t.Repo (string) (string) 7963 7963 + if len("repo") > 1000000 { 7964 7964 + return xerrors.Errorf("Value in field \"repo\" was too long") 7965 7965 + } 7966 7966 + 7967 7967 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 7968 7968 + return err 7969 7969 + } 7970 7970 + if _, err := cw.WriteString(string("repo")); err != nil { 7971 7971 + return err 7972 7972 + } 7973 7973 + 7974 7974 + if len(t.Repo) > 1000000 { 7975 7975 + return xerrors.Errorf("Value in field t.Repo was too long") 7976 7976 + } 7977 7977 + 7978 7978 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 7979 7979 + return err 7980 7980 + } 7981 7981 + if _, err := cw.WriteString(string(t.Repo)); err != nil { 7982 7982 + return err 7983 7983 + } 7984 7984 + 7985 7985 + // t.LexiconTypeID (string) (string) 7986 7986 + if len("$type") > 1000000 { 7987 7987 + return xerrors.Errorf("Value in field \"$type\" was too long") 7988 7988 + } 7989 7989 + 7990 7990 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 7991 7991 + return err 7992 7992 + } 7993 7993 + if _, err := cw.WriteString(string("$type")); err != nil { 7994 7994 + return err 7995 7995 + } 7996 7996 + 7997 7997 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.discussion"))); err != nil { 7998 7998 + return err 7999 7999 + } 8000 8000 + if _, err := cw.WriteString(string("sh.tangled.repo.discussion")); err != nil { 8001 8001 + return err 8002 8002 + } 8003 8003 + 8004 8004 + // t.Title (string) (string) 8005 8005 + if len("title") > 1000000 { 8006 8006 + return xerrors.Errorf("Value in field \"title\" was too long") 8007 8007 + } 8008 8008 + 8009 8009 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil { 8010 8010 + return err 8011 8011 + } 8012 8012 + if _, err := cw.WriteString(string("title")); err != nil { 8013 8013 + return err 8014 8014 + } 8015 8015 + 8016 8016 + if len(t.Title) > 1000000 { 8017 8017 + return xerrors.Errorf("Value in field t.Title was too long") 8018 8018 + } 8019 8019 + 8020 8020 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil { 8021 8021 + return err 8022 8022 + } 8023 8023 + if _, err := cw.WriteString(string(t.Title)); err != nil { 8024 8024 + return err 8025 8025 + } 8026 8026 + 8027 8027 + // t.Mentions ([]string) (slice) 8028 8028 + if t.Mentions != nil { 8029 8029 + 8030 8030 + if len("mentions") > 1000000 { 8031 8031 + return xerrors.Errorf("Value in field \"mentions\" was too long") 8032 8032 + } 8033 8033 + 8034 8034 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil { 8035 8035 + return err 8036 8036 + } 8037 8037 + if _, err := cw.WriteString(string("mentions")); err != nil { 8038 8038 + return err 8039 8039 + } 8040 8040 + 8041 8041 + if len(t.Mentions) > 8192 { 8042 8042 + return xerrors.Errorf("Slice value in field t.Mentions was too long") 8043 8043 + } 8044 8044 + 8045 8045 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil { 8046 8046 + return err 8047 8047 + } 8048 8048 + for _, v := range t.Mentions { 8049 8049 + if len(v) > 1000000 { 8050 8050 + return xerrors.Errorf("Value in field v was too long") 8051 8051 + } 8052 8052 + 8053 8053 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 8054 8054 + return err 8055 8055 + } 8056 8056 + if _, err := cw.WriteString(string(v)); err != nil { 8057 8057 + return err 8058 8058 + } 8059 8059 + 8060 8060 + } 8061 8061 + } 8062 8062 + 8063 8063 + // t.CreatedAt (string) (string) 8064 8064 + if len("createdAt") > 1000000 { 8065 8065 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 8066 8066 + } 8067 8067 + 8068 8068 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 8069 8069 + return err 8070 8070 + } 8071 8071 + if _, err := cw.WriteString(string("createdAt")); err != nil { 8072 8072 + return err 8073 8073 + } 8074 8074 + 8075 8075 + if len(t.CreatedAt) > 1000000 { 8076 8076 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 8077 8077 + } 8078 8078 + 8079 8079 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 8080 8080 + return err 8081 8081 + } 8082 8082 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 8083 8083 + return err 8084 8084 + } 8085 8085 + 8086 8086 + // t.References ([]string) (slice) 8087 8087 + if t.References != nil { 8088 8088 + 8089 8089 + if len("references") > 1000000 { 8090 8090 + return xerrors.Errorf("Value in field \"references\" was too long") 8091 8091 + } 8092 8092 + 8093 8093 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil { 8094 8094 + return err 8095 8095 + } 8096 8096 + if _, err := cw.WriteString(string("references")); err != nil { 8097 8097 + return err 8098 8098 + } 8099 8099 + 8100 8100 + if len(t.References) > 8192 { 8101 8101 + return xerrors.Errorf("Slice value in field t.References was too long") 8102 8102 + } 8103 8103 + 8104 8104 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil { 8105 8105 + return err 8106 8106 + } 8107 8107 + for _, v := range t.References { 8108 8108 + if len(v) > 1000000 { 8109 8109 + return xerrors.Errorf("Value in field v was too long") 8110 8110 + } 8111 8111 + 8112 8112 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 8113 8113 + return err 8114 8114 + } 8115 8115 + if _, err := cw.WriteString(string(v)); err != nil { 8116 8116 + return err 8117 8117 + } 8118 8118 + 8119 8119 + } 8120 8120 + } 8121 8121 + 8122 8122 + // t.TargetChannel (string) (string) 8123 8123 + if t.TargetChannel != nil { 8124 8124 + 8125 8125 + if len("targetChannel") > 1000000 { 8126 8126 + return xerrors.Errorf("Value in field \"targetChannel\" was too long") 8127 8127 + } 8128 8128 + 8129 8129 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetChannel"))); err != nil { 8130 8130 + return err 8131 8131 + } 8132 8132 + if _, err := cw.WriteString(string("targetChannel")); err != nil { 8133 8133 + return err 8134 8134 + } 8135 8135 + 8136 8136 + if t.TargetChannel == nil { 8137 8137 + if _, err := cw.Write(cbg.CborNull); err != nil { 8138 8138 + return err 8139 8139 + } 8140 8140 + } else { 8141 8141 + if len(*t.TargetChannel) > 1000000 { 8142 8142 + return xerrors.Errorf("Value in field t.TargetChannel was too long") 8143 8143 + } 8144 8144 + 8145 8145 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.TargetChannel))); err != nil { 8146 8146 + return err 8147 8147 + } 8148 8148 + if _, err := cw.WriteString(string(*t.TargetChannel)); err != nil { 8149 8149 + return err 8150 8150 + } 8151 8151 + } 8152 8152 + } 8153 8153 + return nil 8154 8154 + } 8155 8155 + 8156 8156 + func (t *RepoDiscussion) UnmarshalCBOR(r io.Reader) (err error) { 8157 8157 + *t = RepoDiscussion{} 8158 8158 + 8159 8159 + cr := cbg.NewCborReader(r) 8160 8160 + 8161 8161 + maj, extra, err := cr.ReadHeader() 8162 8162 + if err != nil { 8163 8163 + return err 8164 8164 + } 8165 8165 + defer func() { 8166 8166 + if err == io.EOF { 8167 8167 + err = io.ErrUnexpectedEOF 8168 8168 + } 8169 8169 + }() 8170 8170 + 8171 8171 + if maj != cbg.MajMap { 8172 8172 + return fmt.Errorf("cbor input should be of type map") 8173 8173 + } 8174 8174 + 8175 8175 + if extra > cbg.MaxLength { 8176 8176 + return fmt.Errorf("RepoDiscussion: map struct too large (%d)", extra) 8177 8177 + } 8178 8178 + 8179 8179 + n := extra 8180 8180 + 8181 8181 + nameBuf := make([]byte, 13) 8182 8182 + for i := uint64(0); i < n; i++ { 8183 8183 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 8184 8184 + if err != nil { 8185 8185 + return err 8186 8186 + } 8187 8187 + 8188 8188 + if !ok { 8189 8189 + // Field doesn't exist on this type, so ignore it 8190 8190 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 8191 8191 + return err 8192 8192 + } 8193 8193 + continue 8194 8194 + } 8195 8195 + 8196 8196 + switch string(nameBuf[:nameLen]) { 8197 8197 + // t.Body (string) (string) 8198 8198 + case "body": 8199 8199 + 8200 8200 + { 8201 8201 + b, err := cr.ReadByte() 8202 8202 + if err != nil { 8203 8203 + return err 8204 8204 + } 8205 8205 + if b != cbg.CborNull[0] { 8206 8206 + if err := cr.UnreadByte(); err != nil { 8207 8207 + return err 8208 8208 + } 8209 8209 + 8210 8210 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8211 8211 + if err != nil { 8212 8212 + return err 8213 8213 + } 8214 8214 + 8215 8215 + t.Body = (*string)(&sval) 8216 8216 + } 8217 8217 + } 8218 8218 + // t.Repo (string) (string) 8219 8219 + case "repo": 8220 8220 + 8221 8221 + { 8222 8222 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8223 8223 + if err != nil { 8224 8224 + return err 8225 8225 + } 8226 8226 + 8227 8227 + t.Repo = string(sval) 8228 8228 + } 8229 8229 + // t.LexiconTypeID (string) (string) 8230 8230 + case "$type": 8231 8231 + 8232 8232 + { 8233 8233 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8234 8234 + if err != nil { 8235 8235 + return err 8236 8236 + } 8237 8237 + 8238 8238 + t.LexiconTypeID = string(sval) 8239 8239 + } 8240 8240 + // t.Title (string) (string) 8241 8241 + case "title": 8242 8242 + 8243 8243 + { 8244 8244 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8245 8245 + if err != nil { 8246 8246 + return err 8247 8247 + } 8248 8248 + 8249 8249 + t.Title = string(sval) 8250 8250 + } 8251 8251 + // t.Mentions ([]string) (slice) 8252 8252 + case "mentions": 8253 8253 + 8254 8254 + maj, extra, err = cr.ReadHeader() 8255 8255 + if err != nil { 8256 8256 + return err 8257 8257 + } 8258 8258 + 8259 8259 + if extra > 8192 { 8260 8260 + return fmt.Errorf("t.Mentions: array too large (%d)", extra) 8261 8261 + } 8262 8262 + 8263 8263 + if maj != cbg.MajArray { 8264 8264 + return fmt.Errorf("expected cbor array") 8265 8265 + } 8266 8266 + 8267 8267 + if extra > 0 { 8268 8268 + t.Mentions = make([]string, extra) 8269 8269 + } 8270 8270 + 8271 8271 + for i := 0; i < int(extra); i++ { 8272 8272 + { 8273 8273 + var maj byte 8274 8274 + var extra uint64 8275 8275 + var err error 8276 8276 + _ = maj 8277 8277 + _ = extra 8278 8278 + _ = err 8279 8279 + 8280 8280 + { 8281 8281 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8282 8282 + if err != nil { 8283 8283 + return err 8284 8284 + } 8285 8285 + 8286 8286 + t.Mentions[i] = string(sval) 8287 8287 + } 8288 8288 + 8289 8289 + } 8290 8290 + } 8291 8291 + // t.CreatedAt (string) (string) 8292 8292 + case "createdAt": 8293 8293 + 8294 8294 + { 8295 8295 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8296 8296 + if err != nil { 8297 8297 + return err 8298 8298 + } 8299 8299 + 8300 8300 + t.CreatedAt = string(sval) 8301 8301 + } 8302 8302 + // t.References ([]string) (slice) 8303 8303 + case "references": 8304 8304 + 8305 8305 + maj, extra, err = cr.ReadHeader() 8306 8306 + if err != nil { 8307 8307 + return err 8308 8308 + } 8309 8309 + 8310 8310 + if extra > 8192 { 8311 8311 + return fmt.Errorf("t.References: array too large (%d)", extra) 8312 8312 + } 8313 8313 + 8314 8314 + if maj != cbg.MajArray { 8315 8315 + return fmt.Errorf("expected cbor array") 8316 8316 + } 8317 8317 + 8318 8318 + if extra > 0 { 8319 8319 + t.References = make([]string, extra) 8320 8320 + } 8321 8321 + 8322 8322 + for i := 0; i < int(extra); i++ { 8323 8323 + { 8324 8324 + var maj byte 8325 8325 + var extra uint64 8326 8326 + var err error 8327 8327 + _ = maj 8328 8328 + _ = extra 8329 8329 + _ = err 8330 8330 + 8331 8331 + { 8332 8332 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8333 8333 + if err != nil { 8334 8334 + return err 8335 8335 + } 8336 8336 + 8337 8337 + t.References[i] = string(sval) 8338 8338 + } 8339 8339 + 8340 8340 + } 8341 8341 + } 8342 8342 + // t.TargetChannel (string) (string) 8343 8343 + case "targetChannel": 8344 8344 + 8345 8345 + { 8346 8346 + b, err := cr.ReadByte() 8347 8347 + if err != nil { 8348 8348 + return err 8349 8349 + } 8350 8350 + if b != cbg.CborNull[0] { 8351 8351 + if err := cr.UnreadByte(); err != nil { 8352 8352 + return err 8353 8353 + } 8354 8354 + 8355 8355 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8356 8356 + if err != nil { 8357 8357 + return err 8358 8358 + } 8359 8359 + 8360 8360 + t.TargetChannel = (*string)(&sval) 8361 8361 + } 8362 8362 + } 8363 8363 + 8364 8364 + default: 8365 8365 + // Field doesn't exist on this type, so ignore it 8366 8366 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 8367 8367 + return err 8368 8368 + } 8369 8369 + } 8370 8370 + } 8371 8371 + 8372 8372 + return nil 8373 8373 + } 8374 8374 + func (t *RepoDiscussionComment) MarshalCBOR(w io.Writer) error { 8375 8375 + if t == nil { 8376 8376 + _, err := w.Write(cbg.CborNull) 8377 8377 + return err 8378 8378 + } 8379 8379 + 8380 8380 + cw := cbg.NewCborWriter(w) 8381 8381 + fieldCount := 7 8382 8382 + 8383 8383 + if t.Mentions == nil { 8384 8384 + fieldCount-- 8385 8385 + } 8386 8386 + 8387 8387 + if t.References == nil { 8388 8388 + fieldCount-- 8389 8389 + } 8390 8390 + 8391 8391 + if t.ReplyTo == nil { 8392 8392 + fieldCount-- 8393 8393 + } 8394 8394 + 8395 8395 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 8396 8396 + return err 8397 8397 + } 8398 8398 + 8399 8399 + // t.Body (string) (string) 8400 8400 + if len("body") > 1000000 { 8401 8401 + return xerrors.Errorf("Value in field \"body\" was too long") 8402 8402 + } 8403 8403 + 8404 8404 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 8405 8405 + return err 8406 8406 + } 8407 8407 + if _, err := cw.WriteString(string("body")); err != nil { 8408 8408 + return err 8409 8409 + } 8410 8410 + 8411 8411 + if len(t.Body) > 1000000 { 8412 8412 + return xerrors.Errorf("Value in field t.Body was too long") 8413 8413 + } 8414 8414 + 8415 8415 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil { 8416 8416 + return err 8417 8417 + } 8418 8418 + if _, err := cw.WriteString(string(t.Body)); err != nil { 8419 8419 + return err 8420 8420 + } 8421 8421 + 8422 8422 + // t.LexiconTypeID (string) (string) 8423 8423 + if len("$type") > 1000000 { 8424 8424 + return xerrors.Errorf("Value in field \"$type\" was too long") 8425 8425 + } 8426 8426 + 8427 8427 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 8428 8428 + return err 8429 8429 + } 8430 8430 + if _, err := cw.WriteString(string("$type")); err != nil { 8431 8431 + return err 8432 8432 + } 8433 8433 + 8434 8434 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.discussion.comment"))); err != nil { 8435 8435 + return err 8436 8436 + } 8437 8437 + if _, err := cw.WriteString(string("sh.tangled.repo.discussion.comment")); err != nil { 8438 8438 + return err 8439 8439 + } 8440 8440 + 8441 8441 + // t.ReplyTo (string) (string) 8442 8442 + if t.ReplyTo != nil { 8443 8443 + 8444 8444 + if len("replyTo") > 1000000 { 8445 8445 + return xerrors.Errorf("Value in field \"replyTo\" was too long") 8446 8446 + } 8447 8447 + 8448 8448 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil { 8449 8449 + return err 8450 8450 + } 8451 8451 + if _, err := cw.WriteString(string("replyTo")); err != nil { 8452 8452 + return err 8453 8453 + } 8454 8454 + 8455 8455 + if t.ReplyTo == nil { 8456 8456 + if _, err := cw.Write(cbg.CborNull); err != nil { 8457 8457 + return err 8458 8458 + } 8459 8459 + } else { 8460 8460 + if len(*t.ReplyTo) > 1000000 { 8461 8461 + return xerrors.Errorf("Value in field t.ReplyTo was too long") 8462 8462 + } 8463 8463 + 8464 8464 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil { 8465 8465 + return err 8466 8466 + } 8467 8467 + if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil { 8468 8468 + return err 8469 8469 + } 8470 8470 + } 8471 8471 + } 8472 8472 + 8473 8473 + // t.Mentions ([]string) (slice) 8474 8474 + if t.Mentions != nil { 8475 8475 + 8476 8476 + if len("mentions") > 1000000 { 8477 8477 + return xerrors.Errorf("Value in field \"mentions\" was too long") 8478 8478 + } 8479 8479 + 8480 8480 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil { 8481 8481 + return err 8482 8482 + } 8483 8483 + if _, err := cw.WriteString(string("mentions")); err != nil { 8484 8484 + return err 8485 8485 + } 8486 8486 + 8487 8487 + if len(t.Mentions) > 8192 { 8488 8488 + return xerrors.Errorf("Slice value in field t.Mentions was too long") 8489 8489 + } 8490 8490 + 8491 8491 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil { 8492 8492 + return err 8493 8493 + } 8494 8494 + for _, v := range t.Mentions { 8495 8495 + if len(v) > 1000000 { 8496 8496 + return xerrors.Errorf("Value in field v was too long") 8497 8497 + } 8498 8498 + 8499 8499 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 8500 8500 + return err 8501 8501 + } 8502 8502 + if _, err := cw.WriteString(string(v)); err != nil { 8503 8503 + return err 8504 8504 + } 8505 8505 + 8506 8506 + } 8507 8507 + } 8508 8508 + 8509 8509 + // t.CreatedAt (string) (string) 8510 8510 + if len("createdAt") > 1000000 { 8511 8511 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 8512 8512 + } 8513 8513 + 8514 8514 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 8515 8515 + return err 8516 8516 + } 8517 8517 + if _, err := cw.WriteString(string("createdAt")); err != nil { 8518 8518 + return err 8519 8519 + } 8520 8520 + 8521 8521 + if len(t.CreatedAt) > 1000000 { 8522 8522 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 8523 8523 + } 8524 8524 + 8525 8525 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 8526 8526 + return err 8527 8527 + } 8528 8528 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 8529 8529 + return err 8530 8530 + } 8531 8531 + 8532 8532 + // t.Discussion (string) (string) 8533 8533 + if len("discussion") > 1000000 { 8534 8534 + return xerrors.Errorf("Value in field \"discussion\" was too long") 8535 8535 + } 8536 8536 + 8537 8537 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("discussion"))); err != nil { 8538 8538 + return err 8539 8539 + } 8540 8540 + if _, err := cw.WriteString(string("discussion")); err != nil { 8541 8541 + return err 8542 8542 + } 8543 8543 + 8544 8544 + if len(t.Discussion) > 1000000 { 8545 8545 + return xerrors.Errorf("Value in field t.Discussion was too long") 8546 8546 + } 8547 8547 + 8548 8548 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Discussion))); err != nil { 8549 8549 + return err 8550 8550 + } 8551 8551 + if _, err := cw.WriteString(string(t.Discussion)); err != nil { 8552 8552 + return err 8553 8553 + } 8554 8554 + 8555 8555 + // t.References ([]string) (slice) 8556 8556 + if t.References != nil { 8557 8557 + 8558 8558 + if len("references") > 1000000 { 8559 8559 + return xerrors.Errorf("Value in field \"references\" was too long") 8560 8560 + } 8561 8561 + 8562 8562 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil { 8563 8563 + return err 8564 8564 + } 8565 8565 + if _, err := cw.WriteString(string("references")); err != nil { 8566 8566 + return err 8567 8567 + } 8568 8568 + 8569 8569 + if len(t.References) > 8192 { 8570 8570 + return xerrors.Errorf("Slice value in field t.References was too long") 8571 8571 + } 8572 8572 + 8573 8573 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil { 8574 8574 + return err 8575 8575 + } 8576 8576 + for _, v := range t.References { 8577 8577 + if len(v) > 1000000 { 8578 8578 + return xerrors.Errorf("Value in field v was too long") 8579 8579 + } 8580 8580 + 8581 8581 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 8582 8582 + return err 8583 8583 + } 8584 8584 + if _, err := cw.WriteString(string(v)); err != nil { 8585 8585 + return err 8586 8586 + } 8587 8587 + 8588 8588 + } 8589 8589 + } 8590 8590 + return nil 8591 8591 + } 8592 8592 + 8593 8593 + func (t *RepoDiscussionComment) UnmarshalCBOR(r io.Reader) (err error) { 8594 8594 + *t = RepoDiscussionComment{} 8595 8595 + 8596 8596 + cr := cbg.NewCborReader(r) 8597 8597 + 8598 8598 + maj, extra, err := cr.ReadHeader() 8599 8599 + if err != nil { 8600 8600 + return err 8601 8601 + } 8602 8602 + defer func() { 8603 8603 + if err == io.EOF { 8604 8604 + err = io.ErrUnexpectedEOF 8605 8605 + } 8606 8606 + }() 8607 8607 + 8608 8608 + if maj != cbg.MajMap { 8609 8609 + return fmt.Errorf("cbor input should be of type map") 8610 8610 + } 8611 8611 + 8612 8612 + if extra > cbg.MaxLength { 8613 8613 + return fmt.Errorf("RepoDiscussionComment: map struct too large (%d)", extra) 8614 8614 + } 8615 8615 + 8616 8616 + n := extra 8617 8617 + 8618 8618 + nameBuf := make([]byte, 10) 8619 8619 + for i := uint64(0); i < n; i++ { 8620 8620 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 8621 8621 + if err != nil { 8622 8622 + return err 8623 8623 + } 8624 8624 + 8625 8625 + if !ok { 8626 8626 + // Field doesn't exist on this type, so ignore it 8627 8627 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 8628 8628 + return err 8629 8629 + } 8630 8630 + continue 8631 8631 + } 8632 8632 + 8633 8633 + switch string(nameBuf[:nameLen]) { 8634 8634 + // t.Body (string) (string) 8635 8635 + case "body": 8636 8636 + 8637 8637 + { 8638 8638 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8639 8639 + if err != nil { 8640 8640 + return err 8641 8641 + } 8642 8642 + 8643 8643 + t.Body = string(sval) 8644 8644 + } 8645 8645 + // t.LexiconTypeID (string) (string) 8646 8646 + case "$type": 8647 8647 + 8648 8648 + { 8649 8649 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8650 8650 + if err != nil { 8651 8651 + return err 8652 8652 + } 8653 8653 + 8654 8654 + t.LexiconTypeID = string(sval) 8655 8655 + } 8656 8656 + // t.ReplyTo (string) (string) 8657 8657 + case "replyTo": 8658 8658 + 8659 8659 + { 8660 8660 + b, err := cr.ReadByte() 8661 8661 + if err != nil { 8662 8662 + return err 8663 8663 + } 8664 8664 + if b != cbg.CborNull[0] { 8665 8665 + if err := cr.UnreadByte(); err != nil { 8666 8666 + return err 8667 8667 + } 8668 8668 + 8669 8669 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8670 8670 + if err != nil { 8671 8671 + return err 8672 8672 + } 8673 8673 + 8674 8674 + t.ReplyTo = (*string)(&sval) 8675 8675 + } 8676 8676 + } 8677 8677 + // t.Mentions ([]string) (slice) 8678 8678 + case "mentions": 8679 8679 + 8680 8680 + maj, extra, err = cr.ReadHeader() 8681 8681 + if err != nil { 8682 8682 + return err 8683 8683 + } 8684 8684 + 8685 8685 + if extra > 8192 { 8686 8686 + return fmt.Errorf("t.Mentions: array too large (%d)", extra) 8687 8687 + } 8688 8688 + 8689 8689 + if maj != cbg.MajArray { 8690 8690 + return fmt.Errorf("expected cbor array") 8691 8691 + } 8692 8692 + 8693 8693 + if extra > 0 { 8694 8694 + t.Mentions = make([]string, extra) 8695 8695 + } 8696 8696 + 8697 8697 + for i := 0; i < int(extra); i++ { 8698 8698 + { 8699 8699 + var maj byte 8700 8700 + var extra uint64 8701 8701 + var err error 8702 8702 + _ = maj 8703 8703 + _ = extra 8704 8704 + _ = err 8705 8705 + 8706 8706 + { 8707 8707 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8708 8708 + if err != nil { 8709 8709 + return err 8710 8710 + } 8711 8711 + 8712 8712 + t.Mentions[i] = string(sval) 8713 8713 + } 8714 8714 + 8715 8715 + } 8716 8716 + } 8717 8717 + // t.CreatedAt (string) (string) 8718 8718 + case "createdAt": 8719 8719 + 8720 8720 + { 8721 8721 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8722 8722 + if err != nil { 8723 8723 + return err 8724 8724 + } 8725 8725 + 8726 8726 + t.CreatedAt = string(sval) 8727 8727 + } 8728 8728 + // t.Discussion (string) (string) 8729 8729 + case "discussion": 8730 8730 + 8731 8731 + { 8732 8732 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8733 8733 + if err != nil { 8734 8734 + return err 8735 8735 + } 8736 8736 + 8737 8737 + t.Discussion = string(sval) 8738 8738 + } 8739 8739 + // t.References ([]string) (slice) 8740 8740 + case "references": 8741 8741 + 8742 8742 + maj, extra, err = cr.ReadHeader() 8743 8743 + if err != nil { 8744 8744 + return err 8745 8745 + } 8746 8746 + 8747 8747 + if extra > 8192 { 8748 8748 + return fmt.Errorf("t.References: array too large (%d)", extra) 8749 8749 + } 8750 8750 + 8751 8751 + if maj != cbg.MajArray { 8752 8752 + return fmt.Errorf("expected cbor array") 8753 8753 + } 8754 8754 + 8755 8755 + if extra > 0 { 8756 8756 + t.References = make([]string, extra) 8757 8757 + } 8758 8758 + 8759 8759 + for i := 0; i < int(extra); i++ { 8760 8760 + { 8761 8761 + var maj byte 8762 8762 + var extra uint64 8763 8763 + var err error 8764 8764 + _ = maj 8765 8765 + _ = extra 8766 8766 + _ = err 8767 8767 + 8768 8768 + { 8769 8769 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8770 8770 + if err != nil { 8771 8771 + return err 8772 8772 + } 8773 8773 + 8774 8774 + t.References[i] = string(sval) 8775 8775 + } 8776 8776 + 8777 8777 + } 8778 8778 + } 8779 8779 + 8780 8780 + default: 8781 8781 + // Field doesn't exist on this type, so ignore it 8782 8782 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 8783 8783 + return err 8784 8784 + } 8785 8785 + } 8786 8786 + } 8787 8787 + 8788 8788 + return nil 8789 8789 + } 8790 8790 + func (t *RepoDiscussionState) MarshalCBOR(w io.Writer) error { 8791 8791 + if t == nil { 8792 8792 + _, err := w.Write(cbg.CborNull) 8793 8793 + return err 8794 8794 + } 8795 8795 + 8796 8796 + cw := cbg.NewCborWriter(w) 8797 8797 + 8798 8798 + if _, err := cw.Write([]byte{164}); err != nil { 8799 8799 + return err 8800 8800 + } 8801 8801 + 8802 8802 + // t.LexiconTypeID (string) (string) 8803 8803 + if len("$type") > 1000000 { 8804 8804 + return xerrors.Errorf("Value in field \"$type\" was too long") 8805 8805 + } 8806 8806 + 8807 8807 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 8808 8808 + return err 8809 8809 + } 8810 8810 + if _, err := cw.WriteString(string("$type")); err != nil { 8811 8811 + return err 8812 8812 + } 8813 8813 + 8814 8814 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.discussion.state"))); err != nil { 8815 8815 + return err 8816 8816 + } 8817 8817 + if _, err := cw.WriteString(string("sh.tangled.repo.discussion.state")); err != nil { 8818 8818 + return err 8819 8819 + } 8820 8820 + 8821 8821 + // t.State (string) (string) 8822 8822 + if len("state") > 1000000 { 8823 8823 + return xerrors.Errorf("Value in field \"state\" was too long") 8824 8824 + } 8825 8825 + 8826 8826 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil { 8827 8827 + return err 8828 8828 + } 8829 8829 + if _, err := cw.WriteString(string("state")); err != nil { 8830 8830 + return err 8831 8831 + } 8832 8832 + 8833 8833 + if len(t.State) > 1000000 { 8834 8834 + return xerrors.Errorf("Value in field t.State was too long") 8835 8835 + } 8836 8836 + 8837 8837 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil { 8838 8838 + return err 8839 8839 + } 8840 8840 + if _, err := cw.WriteString(string(t.State)); err != nil { 8841 8841 + return err 8842 8842 + } 8843 8843 + 8844 8844 + // t.CreatedAt (string) (string) 8845 8845 + if len("createdAt") > 1000000 { 8846 8846 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 8847 8847 + } 8848 8848 + 8849 8849 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 8850 8850 + return err 8851 8851 + } 8852 8852 + if _, err := cw.WriteString(string("createdAt")); err != nil { 8853 8853 + return err 8854 8854 + } 8855 8855 + 8856 8856 + if len(t.CreatedAt) > 1000000 { 8857 8857 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 8858 8858 + } 8859 8859 + 8860 8860 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 8861 8861 + return err 8862 8862 + } 8863 8863 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 8864 8864 + return err 8865 8865 + } 8866 8866 + 8867 8867 + // t.Discussion (string) (string) 8868 8868 + if len("discussion") > 1000000 { 8869 8869 + return xerrors.Errorf("Value in field \"discussion\" was too long") 8870 8870 + } 8871 8871 + 8872 8872 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("discussion"))); err != nil { 8873 8873 + return err 8874 8874 + } 8875 8875 + if _, err := cw.WriteString(string("discussion")); err != nil { 8876 8876 + return err 8877 8877 + } 8878 8878 + 8879 8879 + if len(t.Discussion) > 1000000 { 8880 8880 + return xerrors.Errorf("Value in field t.Discussion was too long") 8881 8881 + } 8882 8882 + 8883 8883 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Discussion))); err != nil { 8884 8884 + return err 8885 8885 + } 8886 8886 + if _, err := cw.WriteString(string(t.Discussion)); err != nil { 8887 8887 + return err 8888 8888 + } 8889 8889 + return nil 8890 8890 + } 8891 8891 + 8892 8892 + func (t *RepoDiscussionState) UnmarshalCBOR(r io.Reader) (err error) { 8893 8893 + *t = RepoDiscussionState{} 8894 8894 + 8895 8895 + cr := cbg.NewCborReader(r) 8896 8896 + 8897 8897 + maj, extra, err := cr.ReadHeader() 8898 8898 + if err != nil { 8899 8899 + return err 8900 8900 + } 8901 8901 + defer func() { 8902 8902 + if err == io.EOF { 8903 8903 + err = io.ErrUnexpectedEOF 8904 8904 + } 8905 8905 + }() 8906 8906 + 8907 8907 + if maj != cbg.MajMap { 8908 8908 + return fmt.Errorf("cbor input should be of type map") 8909 8909 + } 8910 8910 + 8911 8911 + if extra > cbg.MaxLength { 8912 8912 + return fmt.Errorf("RepoDiscussionState: map struct too large (%d)", extra) 8913 8913 + } 8914 8914 + 8915 8915 + n := extra 8916 8916 + 8917 8917 + nameBuf := make([]byte, 10) 8918 8918 + for i := uint64(0); i < n; i++ { 8919 8919 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 8920 8920 + if err != nil { 8921 8921 + return err 8922 8922 + } 8923 8923 + 8924 8924 + if !ok { 8925 8925 + // Field doesn't exist on this type, so ignore it 8926 8926 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 8927 8927 + return err 8928 8928 + } 8929 8929 + continue 8930 8930 + } 8931 8931 + 8932 8932 + switch string(nameBuf[:nameLen]) { 8933 8933 + // t.LexiconTypeID (string) (string) 8934 8934 + case "$type": 8935 8935 + 8936 8936 + { 8937 8937 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8938 8938 + if err != nil { 8939 8939 + return err 8940 8940 + } 8941 8941 + 8942 8942 + t.LexiconTypeID = string(sval) 8943 8943 + } 8944 8944 + // t.State (string) (string) 8945 8945 + case "state": 8946 8946 + 8947 8947 + { 8948 8948 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8949 8949 + if err != nil { 8950 8950 + return err 8951 8951 + } 8952 8952 + 8953 8953 + t.State = string(sval) 8954 8954 + } 8955 8955 + // t.CreatedAt (string) (string) 8956 8956 + case "createdAt": 8957 8957 + 8958 8958 + { 8959 8959 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8960 8960 + if err != nil { 8961 8961 + return err 8962 8962 + } 8963 8963 + 8964 8964 + t.CreatedAt = string(sval) 8965 8965 + } 8966 8966 + // t.Discussion (string) (string) 8967 8967 + case "discussion": 8968 8968 + 8969 8969 + { 8970 8970 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8971 8971 + if err != nil { 8972 8972 + return err 8973 8973 + } 8974 8974 + 8975 8975 + t.Discussion = string(sval) 7483 8976 } 7484 8977 7485 8978 default:

+30

api/tangled/discussioncomment.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.repo.discussion.comment 6 6 + 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + RepoDiscussionCommentNSID = "sh.tangled.repo.discussion.comment" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.repo.discussion.comment", &RepoDiscussionComment{}) 17 17 + } // 18 18 + // RECORDTYPE: RepoDiscussionComment 19 19 + type RepoDiscussionComment struct { 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.repo.discussion.comment" cborgen:"$type,const=sh.tangled.repo.discussion.comment"` 21 21 + // body: Comment text 22 22 + Body string `json:"body" cborgen:"body"` 23 23 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 24 24 + // discussion: The discussion this comment belongs to 25 25 + Discussion string `json:"discussion" cborgen:"discussion"` 26 26 + Mentions []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"` 27 27 + References []string `json:"references,omitempty" cborgen:"references,omitempty"` 28 28 + // replyTo: If this is a reply, the parent comment's at-uri 29 29 + ReplyTo *string `json:"replyTo,omitempty" cborgen:"replyTo,omitempty"` 30 30 + }

+26

api/tangled/discussionstate.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.repo.discussion.state 6 6 + 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + RepoDiscussionStateNSID = "sh.tangled.repo.discussion.state" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.repo.discussion.state", &RepoDiscussionState{}) 17 17 + } // 18 18 + // RECORDTYPE: RepoDiscussionState 19 19 + type RepoDiscussionState struct { 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.repo.discussion.state" cborgen:"$type,const=sh.tangled.repo.discussion.state"` 21 21 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 22 22 + // discussion: The discussion this state change applies to 23 23 + Discussion string `json:"discussion" cborgen:"discussion"` 24 24 + // state: The new state of the discussion 25 25 + State string `json:"state" cborgen:"state"` 26 26 + }

+81

api/tangled/pijulrefUpdate.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.pijul.refUpdate 6 6 + 7 7 + import ( 8 8 + "fmt" 9 9 + "io" 10 10 + 11 11 + cid "github.com/ipfs/go-cid" 12 12 + cbg "github.com/whyrusleeping/cbor-gen" 13 13 + 14 14 + "github.com/bluesky-social/indigo/lex/util" 15 15 + ) 16 16 + 17 17 + const ( 18 18 + PijulRefUpdateNSID = "sh.tangled.pijul.refUpdate" 19 19 + ) 20 20 + 21 21 + func init() { 22 22 + util.RegisterType("sh.tangled.pijul.refUpdate", &PijulRefUpdate{}) 23 23 + } // 24 24 + // RECORDTYPE: PijulRefUpdate 25 25 + type PijulRefUpdate struct { 26 26 + LexiconTypeID string `json:"$type,const=sh.tangled.pijul.refUpdate" cborgen:"$type,const=sh.tangled.pijul.refUpdate"` 27 27 + // changes: Base32 change hashes pushed in this operation, in application order 28 28 + Changes []string `json:"changes" cborgen:"changes"` 29 29 + // channel: Channel that was updated 30 30 + Channel string `json:"channel" cborgen:"channel"` 31 31 + // committerDid: DID of the pusher 32 32 + CommitterDid string `json:"committerDid" cborgen:"committerDid"` 33 33 + // languages: Optional map of language name to line count 34 34 + Languages *PijulRefUpdate_Languages `json:"languages,omitempty" cborgen:"languages,omitempty"` 35 35 + // newState: Pijul Merkle state hash after push 36 36 + NewState string `json:"newState" cborgen:"newState"` 37 37 + // oldState: Pijul Merkle state hash before push (empty for new channels) 38 38 + OldState *string `json:"oldState,omitempty" cborgen:"oldState,omitempty"` 39 39 + // repo: AT URI of the repository 40 40 + Repo string `json:"repo" cborgen:"repo"` 41 41 + } 42 42 + 43 43 + // Map of language name to lines of code 44 44 + type PijulRefUpdate_Languages struct { 45 45 + } 46 46 + 47 47 + func (t *PijulRefUpdate_Languages) MarshalCBOR(w io.Writer) error { 48 48 + if t == nil { 49 49 + _, err := w.Write(cbg.CborNull) 50 50 + return err 51 51 + } 52 52 + cw := cbg.NewCborWriter(w) 53 53 + if err := cw.WriteMajorTypeHeader(cbg.MajMap, 0); err != nil { 54 54 + return err 55 55 + } 56 56 + return nil 57 57 + } 58 58 + 59 59 + func (t *PijulRefUpdate_Languages) UnmarshalCBOR(r io.Reader) error { 60 60 + *t = PijulRefUpdate_Languages{} 61 61 + cr := cbg.NewCborReader(r) 62 62 + maj, extra, err := cr.ReadHeader() 63 63 + if err != nil { 64 64 + return err 65 65 + } 66 66 + if maj != cbg.MajMap { 67 67 + return fmt.Errorf("expected cbor map for PijulRefUpdate_Languages") 68 68 + } 69 69 + // skip all entries 70 70 + for i := uint64(0); i < extra; i++ { 71 71 + // skip key 72 72 + if err := cbg.ScanForLinks(cr, func(_ cid.Cid) {}); err != nil { 73 73 + return err 74 74 + } 75 75 + // skip value 76 76 + if err := cbg.ScanForLinks(cr, func(_ cid.Cid) {}); err != nil { 77 77 + return err 78 78 + } 79 79 + } 80 80 + return nil 81 81 + }

+50

api/tangled/repoapplyChanges.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.repo.applyChanges 6 6 + 7 7 + import ( 8 8 + "context" 9 9 + 10 10 + "github.com/bluesky-social/indigo/lex/util" 11 11 + ) 12 12 + 13 13 + const ( 14 14 + RepoApplyChangesNSID = "sh.tangled.repo.applyChanges" 15 15 + ) 16 16 + 17 17 + // RepoApplyChanges_Input is the input argument to a sh.tangled.repo.applyChanges call. 18 18 + type RepoApplyChanges_Input struct { 19 19 + // changes: List of change hashes to apply (in order) 20 20 + Changes []string `json:"changes" cborgen:"changes"` 21 21 + // channel: Target channel to apply changes to 22 22 + Channel string `json:"channel" cborgen:"channel"` 23 23 + // repo: Repository identifier in format 'did:plc:.../repoName' 24 24 + Repo string `json:"repo" cborgen:"repo"` 25 25 + } 26 26 + 27 27 + // RepoApplyChanges_Output is the output of a sh.tangled.repo.applyChanges call. 28 28 + type RepoApplyChanges_Output struct { 29 29 + // applied: List of successfully applied change hashes 30 30 + Applied []string `json:"applied" cborgen:"applied"` 31 31 + // failed: List of changes that failed to apply 32 32 + Failed []*RepoApplyChanges_Output_Failed_Elem `json:"failed,omitempty" cborgen:"failed,omitempty"` 33 33 + // newState: Pijul channel Merkle state hash after applying changes. Empty string if unavailable. 34 34 + NewState string `json:"newState,omitempty" cborgen:"newState,omitempty"` 35 35 + } 36 36 + 37 37 + type RepoApplyChanges_Output_Failed_Elem struct { 38 38 + Error string `json:"error" cborgen:"error"` 39 39 + Hash string `json:"hash" cborgen:"hash"` 40 40 + } 41 41 + 42 42 + // RepoApplyChanges calls the XRPC method "sh.tangled.repo.applyChanges". 43 43 + func RepoApplyChanges(ctx context.Context, c util.LexClient, input *RepoApplyChanges_Input) (*RepoApplyChanges_Output, error) { 44 44 + var out RepoApplyChanges_Output 45 45 + if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.applyChanges", nil, input, &out); err != nil { 46 46 + return nil, err 47 47 + } 48 48 + 49 49 + return &out, nil 50 50 + }

+54

api/tangled/repochangeGet.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.repo.changeGet 6 6 + 7 7 + import ( 8 8 + "context" 9 9 + 10 10 + "github.com/bluesky-social/indigo/lex/util" 11 11 + ) 12 12 + 13 13 + const ( 14 14 + RepoChangeGetNSID = "sh.tangled.repo.changeGet" 15 15 + ) 16 16 + 17 17 + // RepoChangeGet_Author is a "author" in the sh.tangled.repo.changeGet schema. 18 18 + type RepoChangeGet_Author struct { 19 19 + Did *string `json:"did,omitempty" cborgen:"did,omitempty"` 20 20 + Email *string `json:"email,omitempty" cborgen:"email,omitempty"` 21 21 + Name string `json:"name" cborgen:"name"` 22 22 + } 23 23 + 24 24 + // RepoChangeGet_Output is the output of a sh.tangled.repo.changeGet call. 25 25 + type RepoChangeGet_Output struct { 26 26 + Authors []*RepoChangeGet_Author `json:"authors" cborgen:"authors"` 27 27 + // dependencies: Hashes of changes this change depends on 28 28 + Dependencies []string `json:"dependencies,omitempty" cborgen:"dependencies,omitempty"` 29 29 + // diff: Raw diff content of the change 30 30 + Diff *string `json:"diff,omitempty" cborgen:"diff,omitempty"` 31 31 + // hash: Change hash (base32 encoded) 32 32 + Hash string `json:"hash" cborgen:"hash"` 33 33 + // message: Change description 34 34 + Message string `json:"message" cborgen:"message"` 35 35 + // timestamp: When the change was recorded 36 36 + Timestamp *string `json:"timestamp,omitempty" cborgen:"timestamp,omitempty"` 37 37 + } 38 38 + 39 39 + // RepoChangeGet calls the XRPC method "sh.tangled.repo.changeGet". 40 40 + // 41 41 + // hash: Change hash to retrieve 42 42 + // repo: Repository identifier in format 'did:plc:.../repoName' 43 43 + func RepoChangeGet(ctx context.Context, c util.LexClient, hash string, repo string) (*RepoChangeGet_Output, error) { 44 44 + var out RepoChangeGet_Output 45 45 + 46 46 + params := map[string]interface{}{} 47 47 + params["hash"] = hash 48 48 + params["repo"] = repo 49 49 + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.changeGet", params, nil, &out); err != nil { 50 50 + return nil, err 51 51 + } 52 52 + 53 53 + return &out, nil 54 54 + }

+71

api/tangled/repochangeList.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.repo.changeList 6 6 + 7 7 + import ( 8 8 + "context" 9 9 + 10 10 + "github.com/bluesky-social/indigo/lex/util" 11 11 + ) 12 12 + 13 13 + const ( 14 14 + RepoChangeListNSID = "sh.tangled.repo.changeList" 15 15 + ) 16 16 + 17 17 + // RepoChangeList_Author is a "author" in the sh.tangled.repo.changeList schema. 18 18 + type RepoChangeList_Author struct { 19 19 + Did *string `json:"did,omitempty" cborgen:"did,omitempty"` 20 20 + Email *string `json:"email,omitempty" cborgen:"email,omitempty"` 21 21 + Name string `json:"name" cborgen:"name"` 22 22 + } 23 23 + 24 24 + // RepoChangeList_ChangeEntry is a "changeEntry" in the sh.tangled.repo.changeList schema. 25 25 + type RepoChangeList_ChangeEntry struct { 26 26 + Authors []*RepoChangeList_Author `json:"authors" cborgen:"authors"` 27 27 + // dependencies: Hashes of changes this change depends on 28 28 + Dependencies []string `json:"dependencies,omitempty" cborgen:"dependencies,omitempty"` 29 29 + // hash: Change hash (base32 encoded) 30 30 + Hash string `json:"hash" cborgen:"hash"` 31 31 + // message: Change description 32 32 + Message string `json:"message" cborgen:"message"` 33 33 + // timestamp: When the change was recorded 34 34 + Timestamp *string `json:"timestamp,omitempty" cborgen:"timestamp,omitempty"` 35 35 + } 36 36 + 37 37 + // RepoChangeList_Output is the output of a sh.tangled.repo.changeList call. 38 38 + type RepoChangeList_Output struct { 39 39 + Changes []*RepoChangeList_ChangeEntry `json:"changes" cborgen:"changes"` 40 40 + Channel *string `json:"channel,omitempty" cborgen:"channel,omitempty"` 41 41 + Page int64 `json:"page" cborgen:"page"` 42 42 + Per_page int64 `json:"per_page" cborgen:"per_page"` 43 43 + Total int64 `json:"total" cborgen:"total"` 44 44 + } 45 45 + 46 46 + // RepoChangeList calls the XRPC method "sh.tangled.repo.changeList". 47 47 + // 48 48 + // channel: Pijul channel name (defaults to main channel) 49 49 + // cursor: Pagination cursor (offset) 50 50 + // limit: Maximum number of changes to return 51 51 + // repo: Repository identifier in format 'did:plc:.../repoName' 52 52 + func RepoChangeList(ctx context.Context, c util.LexClient, channel string, cursor string, limit int64, repo string) (*RepoChangeList_Output, error) { 53 53 + var out RepoChangeList_Output 54 54 + 55 55 + params := map[string]interface{}{} 56 56 + if channel != "" { 57 57 + params["channel"] = channel 58 58 + } 59 59 + if cursor != "" { 60 60 + params["cursor"] = cursor 61 61 + } 62 62 + if limit != 0 { 63 63 + params["limit"] = limit 64 64 + } 65 65 + params["repo"] = repo 66 66 + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.changeList", params, nil, &out); err != nil { 67 67 + return nil, err 68 68 + } 69 69 + 70 70 + return &out, nil 71 71 + }

+51

api/tangled/repochannelList.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.repo.channelList 6 6 + 7 7 + import ( 8 8 + "context" 9 9 + 10 10 + "github.com/bluesky-social/indigo/lex/util" 11 11 + ) 12 12 + 13 13 + const ( 14 14 + RepoChannelListNSID = "sh.tangled.repo.channelList" 15 15 + ) 16 16 + 17 17 + // RepoChannelList_Channel is a "channel" in the sh.tangled.repo.channelList schema. 18 18 + type RepoChannelList_Channel struct { 19 19 + // is_current: Whether this is the currently active channel 20 20 + Is_current *bool `json:"is_current,omitempty" cborgen:"is_current,omitempty"` 21 21 + // name: Channel name 22 22 + Name string `json:"name" cborgen:"name"` 23 23 + } 24 24 + 25 25 + // RepoChannelList_Output is the output of a sh.tangled.repo.channelList call. 26 26 + type RepoChannelList_Output struct { 27 27 + Channels []*RepoChannelList_Channel `json:"channels" cborgen:"channels"` 28 28 + } 29 29 + 30 30 + // RepoChannelList calls the XRPC method "sh.tangled.repo.channelList". 31 31 + // 32 32 + // cursor: Pagination cursor (offset) 33 33 + // limit: Maximum number of channels to return 34 34 + // repo: Repository identifier in format 'did:plc:.../repoName' 35 35 + func RepoChannelList(ctx context.Context, c util.LexClient, cursor string, limit int64, repo string) (*RepoChannelList_Output, error) { 36 36 + var out RepoChannelList_Output 37 37 + 38 38 + params := map[string]interface{}{} 39 39 + if cursor != "" { 40 40 + params["cursor"] = cursor 41 41 + } 42 42 + if limit != 0 { 43 43 + params["limit"] = limit 44 44 + } 45 45 + params["repo"] = repo 46 46 + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.channelList", params, nil, &out); err != nil { 47 47 + return nil, err 48 48 + } 49 49 + 50 50 + return &out, nil 51 51 + }

+2

api/tangled/repocreate.go

reviewed

··· 26 26 Rkey string `json:"rkey" cborgen:"rkey"` 27 27 // source: A source URL to clone from, populate this when forking or importing a repository. 28 28 Source *string `json:"source,omitempty" cborgen:"source,omitempty"` 29 29 + // vcs: Version control system to use for the repository (git or pijul). 30 30 + Vcs *string `json:"vcs,omitempty" cborgen:"vcs,omitempty"` 29 31 } 30 32 31 33 // RepoCreate_Output is the output of a sh.tangled.repo.create call.

+32

api/tangled/repodiscussion.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.repo.discussion 6 6 + 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + RepoDiscussionNSID = "sh.tangled.repo.discussion" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.repo.discussion", &RepoDiscussion{}) 17 17 + } // 18 18 + // RECORDTYPE: RepoDiscussion 19 19 + type RepoDiscussion struct { 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.repo.discussion" cborgen:"$type,const=sh.tangled.repo.discussion"` 21 21 + // body: Discussion body/description 22 22 + Body *string `json:"body,omitempty" cborgen:"body,omitempty"` 23 23 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 24 24 + Mentions []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"` 25 25 + References []string `json:"references,omitempty" cborgen:"references,omitempty"` 26 26 + // repo: The repository this discussion belongs to 27 27 + Repo string `json:"repo" cborgen:"repo"` 28 28 + // targetChannel: Target Pijul channel for merging patches 29 29 + TargetChannel *string `json:"targetChannel,omitempty" cborgen:"targetChannel,omitempty"` 30 30 + // title: Discussion title 31 31 + Title string `json:"title" cborgen:"title"` 32 32 + }

+36

api/tangled/repogetDefaultChannel.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.repo.getDefaultChannel 6 6 + 7 7 + import ( 8 8 + "context" 9 9 + 10 10 + "github.com/bluesky-social/indigo/lex/util" 11 11 + ) 12 12 + 13 13 + const ( 14 14 + RepoGetDefaultChannelNSID = "sh.tangled.repo.getDefaultChannel" 15 15 + ) 16 16 + 17 17 + // RepoGetDefaultChannel_Output is the output of a sh.tangled.repo.getDefaultChannel call. 18 18 + type RepoGetDefaultChannel_Output struct { 19 19 + // channel: Default channel name 20 20 + Channel string `json:"channel" cborgen:"channel"` 21 21 + } 22 22 + 23 23 + // RepoGetDefaultChannel calls the XRPC method "sh.tangled.repo.getDefaultChannel". 24 24 + // 25 25 + // repo: Repository identifier in format 'did:plc:.../repoName' 26 26 + func RepoGetDefaultChannel(ctx context.Context, c util.LexClient, repo string) (*RepoGetDefaultChannel_Output, error) { 27 27 + var out RepoGetDefaultChannel_Output 28 28 + 29 29 + params := map[string]interface{}{} 30 30 + params["repo"] = repo 31 31 + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.getDefaultChannel", params, nil, &out); err != nil { 32 32 + return nil, err 33 33 + } 34 34 + 35 35 + return &out, nil 36 36 + }

+36

api/tangled/repopermissions.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.repo.permissions 6 6 + 7 7 + import ( 8 8 + "context" 9 9 + 10 10 + "github.com/bluesky-social/indigo/lex/util" 11 11 + ) 12 12 + 13 13 + const ( 14 14 + RepoPermissionsNSID = "sh.tangled.repo.permissions" 15 15 + ) 16 16 + 17 17 + // RepoPermissions_Output is the output of a sh.tangled.repo.permissions call. 18 18 + type RepoPermissions_Output struct { 19 19 + Mask int64 `json:"mask" cborgen:"mask"` 20 20 + Permissions []string `json:"permissions" cborgen:"permissions"` 21 21 + } 22 22 + 23 23 + // RepoPermissions calls the XRPC method "sh.tangled.repo.permissions". 24 24 + // 25 25 + // repo: Repository identifier in format 'did:plc:.../repoName' 26 26 + func RepoPermissions(ctx context.Context, c util.LexClient, repo string) (*RepoPermissions_Output, error) { 27 27 + var out RepoPermissions_Output 28 28 + 29 29 + params := map[string]interface{}{} 30 30 + params["repo"] = repo 31 31 + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.permissions", params, nil, &out); err != nil { 32 32 + return nil, err 33 33 + } 34 34 + 35 35 + return &out, nil 36 36 + }

+48

api/tangled/repopijulBlob.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.repo.pijulBlob 6 6 + 7 7 + import ( 8 8 + "context" 9 9 + 10 10 + "github.com/bluesky-social/indigo/lex/util" 11 11 + ) 12 12 + 13 13 + const ( 14 14 + RepoPijulBlobNSID = "sh.tangled.repo.pijulBlob" 15 15 + ) 16 16 + 17 17 + // RepoPijulBlob_Output is the output of a sh.tangled.repo.pijulBlob call. 18 18 + type RepoPijulBlob_Output struct { 19 19 + // contents: File contents (empty for binary files) 20 20 + Contents *string `json:"contents,omitempty" cborgen:"contents,omitempty"` 21 21 + // is_binary: Whether the file is binary 22 22 + Is_binary bool `json:"is_binary" cborgen:"is_binary"` 23 23 + // path: File path 24 24 + Path string `json:"path" cborgen:"path"` 25 25 + // ref: Channel name 26 26 + Ref *string `json:"ref,omitempty" cborgen:"ref,omitempty"` 27 27 + } 28 28 + 29 29 + // RepoPijulBlob calls the XRPC method "sh.tangled.repo.pijulBlob". 30 30 + // 31 31 + // channel: Pijul channel name (defaults to main channel) 32 32 + // path: Path to the file within the repository 33 33 + // repo: Repository identifier in format 'did:plc:.../repoName' 34 34 + func RepoPijulBlob(ctx context.Context, c util.LexClient, channel string, path string, repo string) (*RepoPijulBlob_Output, error) { 35 35 + var out RepoPijulBlob_Output 36 36 + 37 37 + params := map[string]interface{}{} 38 38 + if channel != "" { 39 39 + params["channel"] = channel 40 40 + } 41 41 + params["path"] = path 42 42 + params["repo"] = repo 43 43 + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.pijulBlob", params, nil, &out); err != nil { 44 44 + return nil, err 45 45 + } 46 46 + 47 47 + return &out, nil 48 48 + }

+63

api/tangled/repopijulTree.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.repo.pijulTree 6 6 + 7 7 + import ( 8 8 + "context" 9 9 + 10 10 + "github.com/bluesky-social/indigo/lex/util" 11 11 + ) 12 12 + 13 13 + const ( 14 14 + RepoPijulTreeNSID = "sh.tangled.repo.pijulTree" 15 15 + ) 16 16 + 17 17 + // RepoPijulTree_Output is the output of a sh.tangled.repo.pijulTree call. 18 18 + type RepoPijulTree_Output struct { 19 19 + // dotdot: Path to navigate up 20 20 + Dotdot *string `json:"dotdot,omitempty" cborgen:"dotdot,omitempty"` 21 21 + Files []*RepoPijulTree_TreeEntry `json:"files" cborgen:"files"` 22 22 + // parent: Parent path 23 23 + Parent *string `json:"parent,omitempty" cborgen:"parent,omitempty"` 24 24 + Readme *RepoPijulTree_Readme `json:"readme,omitempty" cborgen:"readme,omitempty"` 25 25 + // ref: Channel name 26 26 + Ref *string `json:"ref,omitempty" cborgen:"ref,omitempty"` 27 27 + } 28 28 + 29 29 + // RepoPijulTree_Readme is a "readme" in the sh.tangled.repo.pijulTree schema. 30 30 + type RepoPijulTree_Readme struct { 31 31 + Contents *string `json:"contents,omitempty" cborgen:"contents,omitempty"` 32 32 + Filename *string `json:"filename,omitempty" cborgen:"filename,omitempty"` 33 33 + } 34 34 + 35 35 + // RepoPijulTree_TreeEntry is a "treeEntry" in the sh.tangled.repo.pijulTree schema. 36 36 + type RepoPijulTree_TreeEntry struct { 37 37 + Mode string `json:"mode" cborgen:"mode"` 38 38 + Name string `json:"name" cborgen:"name"` 39 39 + Size int64 `json:"size" cborgen:"size"` 40 40 + } 41 41 + 42 42 + // RepoPijulTree calls the XRPC method "sh.tangled.repo.pijulTree". 43 43 + // 44 44 + // channel: Pijul channel name (defaults to main channel) 45 45 + // path: Path within the repository (defaults to root) 46 46 + // repo: Repository identifier in format 'did:plc:.../repoName' 47 47 + func RepoPijulTree(ctx context.Context, c util.LexClient, channel string, path string, repo string) (*RepoPijulTree_Output, error) { 48 48 + var out RepoPijulTree_Output 49 49 + 50 50 + params := map[string]interface{}{} 51 51 + if channel != "" { 52 52 + params["channel"] = channel 53 53 + } 54 54 + if path != "" { 55 55 + params["path"] = path 56 56 + } 57 57 + params["repo"] = repo 58 58 + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.pijulTree", params, nil, &out); err != nil { 59 59 + return nil, err 60 60 + } 61 61 + 62 62 + return &out, nil 63 63 + }

+46

api/tangled/repounrecordChanges.go

reviewed

··· 1 1 + package tangled 2 2 + 3 3 + // schema: sh.tangled.repo.unrecordChanges 4 4 + 5 5 + import ( 6 6 + "context" 7 7 + 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + RepoUnrecordChangesNSID = "sh.tangled.repo.unrecordChanges" 13 13 + ) 14 14 + 15 15 + // RepoUnrecordChanges_Input is the input argument to a sh.tangled.repo.unrecordChanges call. 16 16 + type RepoUnrecordChanges_Input struct { 17 17 + // changes: List of change hashes to unrecord 18 18 + Changes []string `json:"changes" cborgen:"changes"` 19 19 + // channel: Target channel to unrecord changes from (optional) 20 20 + Channel string `json:"channel,omitempty" cborgen:"channel,omitempty"` 21 21 + // repo: Repository identifier in format 'did:plc:.../repoName' 22 22 + Repo string `json:"repo" cborgen:"repo"` 23 23 + } 24 24 + 25 25 + // RepoUnrecordChanges_Output is the output of a sh.tangled.repo.unrecordChanges call. 26 26 + type RepoUnrecordChanges_Output struct { 27 27 + // unrecorded: List of successfully unrecorded change hashes 28 28 + Unrecorded []string `json:"unrecorded" cborgen:"unrecorded"` 29 29 + // failed: List of changes that failed to unrecord 30 30 + Failed []*RepoUnrecordChanges_Output_Failed_Elem `json:"failed,omitempty" cborgen:"failed,omitempty"` 31 31 + } 32 32 + 33 33 + type RepoUnrecordChanges_Output_Failed_Elem struct { 34 34 + Error string `json:"error" cborgen:"error"` 35 35 + Hash string `json:"hash" cborgen:"hash"` 36 36 + } 37 37 + 38 38 + // RepoUnrecordChanges calls the XRPC method "sh.tangled.repo.unrecordChanges". 39 39 + func RepoUnrecordChanges(ctx context.Context, c util.LexClient, input *RepoUnrecordChanges_Input) (*RepoUnrecordChanges_Output, error) { 40 40 + var out RepoUnrecordChanges_Output 41 41 + if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.unrecordChanges", nil, input, &out); err != nil { 42 42 + return nil, err 43 43 + } 44 44 + 45 45 + return &out, nil 46 46 + }

+146

appview/db/db.go

reviewed

··· 3 3 import ( 4 4 "context" 5 5 "database/sql" 6 6 + "fmt" 6 7 "log/slog" 7 8 "strings" 8 9 ··· 25 26 ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) 26 27 Prepare(query string) (*sql.Stmt, error) 27 28 PrepareContext(ctx context.Context, query string) (*sql.Stmt, error) 29 29 + } 30 30 + 31 31 + func columnExists(tx *sql.Tx, table, column string) (bool, error) { 32 32 + query := fmt.Sprintf("select 1 from pragma_table_info('%s') where name = ? limit 1", table) 33 33 + var one int 34 34 + err := tx.QueryRow(query, column).Scan(&one) 35 35 + if err == sql.ErrNoRows { 36 36 + return false, nil 37 37 + } 38 38 + if err != nil { 39 39 + return false, err 40 40 + } 41 41 + return true, nil 28 42 } 29 43 30 44 func Make(ctx context.Context, dbPath string) (*DB, error) { ··· 76 90 rkey text not null, 77 91 at_uri text not null unique, 78 92 created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 93 93 + vcs text not null default 'git' check (vcs in ('git', 'pijul')), 79 94 unique(did, name, knot, rkey) 80 95 ); 81 96 create table if not exists collaborators ( ··· 1258 1273 }) 1259 1274 1260 1275 orm.RunMigration(conn, logger, "add-avatar-to-profile", func(tx *sql.Tx) error { 1276 1276 + colExists, colErr := columnExists(tx, "profile", "avatar") 1277 1277 + if colErr != nil { 1278 1278 + return colErr 1279 1279 + } 1280 1280 + if colExists { 1281 1281 + return nil 1282 1282 + } 1261 1283 _, err := tx.Exec(` 1262 1284 alter table profile add column avatar text; 1263 1285 `) ··· 1288 1310 return err 1289 1311 }) 1290 1312 1313 1313 + // Add vcs column to repos table for pijul support 1314 1314 + orm.RunMigration(conn, logger, "add-vcs-to-repos", func(tx *sql.Tx) error { 1315 1315 + colExists, colErr := columnExists(tx, "repos", "vcs") 1316 1316 + if colErr != nil { 1317 1317 + return colErr 1318 1318 + } 1319 1319 + if colExists { 1320 1320 + return nil 1321 1321 + } 1322 1322 + _, err := tx.Exec(` 1323 1323 + alter table repos add column vcs text not null default 'git' check (vcs in ('git', 'pijul')); 1324 1324 + `) 1325 1325 + return err 1326 1326 + }) 1327 1327 + 1291 1328 orm.RunMigration(conn, logger, "add-preferred-handle-profile", func(tx *sql.Tx) error { 1292 1329 _, err := tx.Exec(` 1293 1330 alter table profile add column preferred_handle text; ··· 1317 1354 unique(user_did, record_nsid, record_rkey) 1318 1355 ); 1319 1356 create index if not exists idx_pds_rewrite_user on pds_rewrite_status(user_did, status); 1357 1357 + `) 1358 1358 + return err 1359 1359 + }) 1360 1360 + 1361 1361 + // Create discussions tables for Pijul repos 1362 1362 + orm.RunMigration(conn, logger, "create-discussions-tables", func(tx *sql.Tx) error { 1363 1363 + _, err := tx.Exec(` 1364 1364 + -- Discussions: unified discussion model for Pijul repos 1365 1365 + create table if not exists discussions ( 1366 1366 + -- identifiers 1367 1367 + id integer primary key autoincrement, 1368 1368 + did text not null, 1369 1369 + rkey text not null, 1370 1370 + at_uri text generated always as ('at://' || did || '/' || 'sh.tangled.repo.discussion' || '/' || rkey) stored, 1371 1371 + 1372 1372 + -- repo reference 1373 1373 + repo_at text not null, 1374 1374 + 1375 1375 + -- sequential ID per repo 1376 1376 + discussion_id integer not null, 1377 1377 + 1378 1378 + -- content 1379 1379 + title text not null, 1380 1380 + body text not null, 1381 1381 + target_channel text not null default 'main', 1382 1382 + 1383 1383 + -- state: 0=closed, 1=open, 2=merged 1384 1384 + state integer not null default 1 check (state in (0, 1, 2)), 1385 1385 + 1386 1386 + -- meta 1387 1387 + created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 1388 1388 + edited text, 1389 1389 + 1390 1390 + -- constraints 1391 1391 + unique(did, rkey), 1392 1392 + unique(repo_at, discussion_id), 1393 1393 + unique(at_uri), 1394 1394 + foreign key (repo_at) references repos(at_uri) on delete cascade 1395 1395 + ); 1396 1396 + 1397 1397 + -- Discussion patches: anyone can add patches to a discussion 1398 1398 + create table if not exists discussion_patches ( 1399 1399 + -- identifiers 1400 1400 + id integer primary key autoincrement, 1401 1401 + discussion_at text not null, 1402 1402 + 1403 1403 + -- who pushed this patch 1404 1404 + pushed_by_did text not null, 1405 1405 + 1406 1406 + -- patch content 1407 1407 + patch_hash text not null, 1408 1408 + patch text not null, 1409 1409 + 1410 1410 + -- meta 1411 1411 + added text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 1412 1412 + removed text, -- NULL means active, timestamp means removed 1413 1413 + 1414 1414 + -- constraints 1415 1415 + unique(discussion_at, patch_hash), 1416 1416 + foreign key (discussion_at) references discussions(at_uri) on delete cascade 1417 1417 + ); 1418 1418 + 1419 1419 + -- Discussion comments 1420 1420 + create table if not exists discussion_comments ( 1421 1421 + -- identifiers 1422 1422 + id integer primary key autoincrement, 1423 1423 + did text not null, 1424 1424 + rkey text, 1425 1425 + at_uri text generated always as ('at://' || did || '/' || 'sh.tangled.repo.discussion.comment' || '/' || rkey) stored, 1426 1426 + 1427 1427 + -- parent references 1428 1428 + discussion_at text not null, 1429 1429 + reply_to text, -- at_uri of parent comment for threading 1430 1430 + 1431 1431 + -- content 1432 1432 + body text not null, 1433 1433 + created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 1434 1434 + edited text, 1435 1435 + deleted text, 1436 1436 + 1437 1437 + -- constraints 1438 1438 + unique(did, rkey), 1439 1439 + unique(at_uri), 1440 1440 + foreign key (discussion_at) references discussions(at_uri) on delete cascade 1441 1441 + ); 1442 1442 + 1443 1443 + -- Discussion subscriptions: who is watching a discussion 1444 1444 + create table if not exists discussion_subscriptions ( 1445 1445 + id integer primary key autoincrement, 1446 1446 + discussion_at text not null, 1447 1447 + subscriber_did text not null, 1448 1448 + created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 1449 1449 + 1450 1450 + unique(discussion_at, subscriber_did), 1451 1451 + foreign key (discussion_at) references discussions(at_uri) on delete cascade 1452 1452 + ); 1453 1453 + 1454 1454 + -- Sequential ID generator for discussions per repo 1455 1455 + create table if not exists repo_discussion_seqs ( 1456 1456 + repo_at text primary key, 1457 1457 + next_discussion_id integer not null default 1 1458 1458 + ); 1459 1459 + 1460 1460 + -- indexes for discussions 1461 1461 + create index if not exists idx_discussions_repo_at on discussions(repo_at); 1462 1462 + create index if not exists idx_discussions_state on discussions(state); 1463 1463 + create index if not exists idx_discussion_patches_discussion_at on discussion_patches(discussion_at); 1464 1464 + create index if not exists idx_discussion_patches_pushed_by on discussion_patches(pushed_by_did); 1465 1465 + create index if not exists idx_discussion_comments_discussion_at on discussion_comments(discussion_at); 1320 1466 `) 1321 1467 return err 1322 1468 })

+632

appview/db/discussions.go

reviewed

··· 1 1 + package db 2 2 + 3 3 + import ( 4 4 + "database/sql" 5 5 + "fmt" 6 6 + "maps" 7 7 + "slices" 8 8 + "sort" 9 9 + "strings" 10 10 + "time" 11 11 + 12 12 + "github.com/bluesky-social/indigo/atproto/syntax" 13 13 + "tangled.org/core/appview/models" 14 14 + "tangled.org/core/appview/pagination" 15 15 + "tangled.org/core/orm" 16 16 + ) 17 17 + 18 18 + // NewDiscussion creates a new discussion in a Pijul repository 19 19 + func NewDiscussion(tx *sql.Tx, discussion *models.Discussion) error { 20 20 + // ensure sequence exists 21 21 + _, err := tx.Exec(` 22 22 + insert or ignore into repo_discussion_seqs (repo_at, next_discussion_id) 23 23 + values (?, 1) 24 24 + `, discussion.RepoAt) 25 25 + if err != nil { 26 26 + return err 27 27 + } 28 28 + 29 29 + // get next discussion_id 30 30 + var newDiscussionId int 31 31 + err = tx.QueryRow(` 32 32 + update repo_discussion_seqs 33 33 + set next_discussion_id = next_discussion_id + 1 34 34 + where repo_at = ? 35 35 + returning next_discussion_id - 1 36 36 + `, discussion.RepoAt).Scan(&newDiscussionId) 37 37 + if err != nil { 38 38 + return err 39 39 + } 40 40 + 41 41 + // insert new discussion 42 42 + row := tx.QueryRow(` 43 43 + insert into discussions (repo_at, did, rkey, discussion_id, title, body, target_channel, state) 44 44 + values (?, ?, ?, ?, ?, ?, ?, ?) 45 45 + returning id, discussion_id 46 46 + `, discussion.RepoAt, discussion.Did, discussion.Rkey, newDiscussionId, discussion.Title, discussion.Body, discussion.TargetChannel, discussion.State) 47 47 + 48 48 + err = row.Scan(&discussion.Id, &discussion.DiscussionId) 49 49 + if err != nil { 50 50 + return fmt.Errorf("scan row: %w", err) 51 51 + } 52 52 + 53 53 + return nil 54 54 + } 55 55 + 56 56 + // GetDiscussionsPaginated returns discussions with pagination 57 57 + func GetDiscussionsPaginated(e Execer, page pagination.Page, filters ...orm.Filter) ([]models.Discussion, error) { 58 58 + discussionMap := make(map[string]*models.Discussion) // at-uri -> discussion 59 59 + 60 60 + var conditions []string 61 61 + var args []any 62 62 + 63 63 + for _, filter := range filters { 64 64 + conditions = append(conditions, filter.Condition()) 65 65 + args = append(args, filter.Arg()...) 66 66 + } 67 67 + 68 68 + whereClause := "" 69 69 + if conditions != nil { 70 70 + whereClause = " where " + strings.Join(conditions, " and ") 71 71 + } 72 72 + 73 73 + pLower := orm.FilterGte("row_num", page.Offset+1) 74 74 + pUpper := orm.FilterLte("row_num", page.Offset+page.Limit) 75 75 + 76 76 + pageClause := "" 77 77 + if page.Limit > 0 { 78 78 + args = append(args, pLower.Arg()...) 79 79 + args = append(args, pUpper.Arg()...) 80 80 + pageClause = " where " + pLower.Condition() + " and " + pUpper.Condition() 81 81 + } 82 82 + 83 83 + query := fmt.Sprintf( 84 84 + ` 85 85 + select * from ( 86 86 + select 87 87 + id, 88 88 + did, 89 89 + rkey, 90 90 + repo_at, 91 91 + discussion_id, 92 92 + title, 93 93 + body, 94 94 + target_channel, 95 95 + state, 96 96 + created, 97 97 + edited, 98 98 + row_number() over (order by created desc) as row_num 99 99 + from 100 100 + discussions 101 101 + %s 102 102 + ) ranked_discussions 103 103 + %s 104 104 + `, 105 105 + whereClause, 106 106 + pageClause, 107 107 + ) 108 108 + 109 109 + rows, err := e.Query(query, args...) 110 110 + if err != nil { 111 111 + return nil, fmt.Errorf("failed to query discussions table: %w", err) 112 112 + } 113 113 + defer rows.Close() 114 114 + 115 115 + for rows.Next() { 116 116 + var discussion models.Discussion 117 117 + var createdAt string 118 118 + var editedAt sql.Null[string] 119 119 + var rowNum int64 120 120 + err := rows.Scan( 121 121 + &discussion.Id, 122 122 + &discussion.Did, 123 123 + &discussion.Rkey, 124 124 + &discussion.RepoAt, 125 125 + &discussion.DiscussionId, 126 126 + &discussion.Title, 127 127 + &discussion.Body, 128 128 + &discussion.TargetChannel, 129 129 + &discussion.State, 130 130 + &createdAt, 131 131 + &editedAt, 132 132 + &rowNum, 133 133 + ) 134 134 + if err != nil { 135 135 + return nil, fmt.Errorf("failed to scan discussion: %w", err) 136 136 + } 137 137 + 138 138 + if t, err := time.Parse(time.RFC3339, createdAt); err == nil { 139 139 + discussion.Created = t 140 140 + } 141 141 + 142 142 + if editedAt.Valid { 143 143 + if t, err := time.Parse(time.RFC3339, editedAt.V); err == nil { 144 144 + discussion.Edited = &t 145 145 + } 146 146 + } 147 147 + 148 148 + atUri := discussion.AtUri().String() 149 149 + discussionMap[atUri] = &discussion 150 150 + } 151 151 + 152 152 + // collect reverse repos 153 153 + repoAts := make([]string, 0, len(discussionMap)) 154 154 + for _, discussion := range discussionMap { 155 155 + repoAts = append(repoAts, string(discussion.RepoAt)) 156 156 + } 157 157 + 158 158 + repos, err := GetRepos(e, orm.FilterIn("at_uri", repoAts)) 159 159 + if err != nil { 160 160 + return nil, fmt.Errorf("failed to build repo mappings: %w", err) 161 161 + } 162 162 + 163 163 + repoMap := make(map[string]*models.Repo) 164 164 + for i := range repos { 165 165 + repoMap[string(repos[i].RepoAt())] = &repos[i] 166 166 + } 167 167 + 168 168 + for discussionAt, d := range discussionMap { 169 169 + if r, ok := repoMap[string(d.RepoAt)]; ok { 170 170 + d.Repo = r 171 171 + } else { 172 172 + // do not show up the discussion if the repo is deleted 173 173 + delete(discussionMap, discussionAt) 174 174 + } 175 175 + } 176 176 + 177 177 + // collect patches 178 178 + discussionAts := slices.Collect(maps.Keys(discussionMap)) 179 179 + 180 180 + patches, err := GetDiscussionPatches(e, orm.FilterIn("discussion_at", discussionAts)) 181 181 + if err != nil { 182 182 + return nil, fmt.Errorf("failed to query patches: %w", err) 183 183 + } 184 184 + for _, p := range patches { 185 185 + discussionAt := p.DiscussionAt.String() 186 186 + if discussion, ok := discussionMap[discussionAt]; ok { 187 187 + discussion.Patches = append(discussion.Patches, p) 188 188 + } 189 189 + } 190 190 + 191 191 + // collect comments 192 192 + comments, err := GetDiscussionComments(e, orm.FilterIn("discussion_at", discussionAts)) 193 193 + if err != nil { 194 194 + return nil, fmt.Errorf("failed to query comments: %w", err) 195 195 + } 196 196 + for i := range comments { 197 197 + discussionAt := comments[i].DiscussionAt 198 198 + if discussion, ok := discussionMap[discussionAt]; ok { 199 199 + discussion.Comments = append(discussion.Comments, comments[i]) 200 200 + } 201 201 + } 202 202 + 203 203 + // collect labels for each discussion 204 204 + allLabels, err := GetLabels(e, orm.FilterIn("subject", discussionAts)) 205 205 + if err != nil { 206 206 + return nil, fmt.Errorf("failed to query labels: %w", err) 207 207 + } 208 208 + for discussionAt, labels := range allLabels { 209 209 + if discussion, ok := discussionMap[discussionAt.String()]; ok { 210 210 + discussion.Labels = labels 211 211 + } 212 212 + } 213 213 + 214 214 + var discussions []models.Discussion 215 215 + for _, d := range discussionMap { 216 216 + discussions = append(discussions, *d) 217 217 + } 218 218 + 219 219 + sort.Slice(discussions, func(i, j int) bool { 220 220 + return discussions[i].Created.After(discussions[j].Created) 221 221 + }) 222 222 + 223 223 + return discussions, nil 224 224 + } 225 225 + 226 226 + // GetDiscussion returns a single discussion by repo and ID 227 227 + func GetDiscussion(e Execer, repoAt syntax.ATURI, discussionId int) (*models.Discussion, error) { 228 228 + discussions, err := GetDiscussionsPaginated( 229 229 + e, 230 230 + pagination.Page{}, 231 231 + orm.FilterEq("repo_at", repoAt), 232 232 + orm.FilterEq("discussion_id", discussionId), 233 233 + ) 234 234 + if err != nil { 235 235 + return nil, err 236 236 + } 237 237 + if len(discussions) != 1 { 238 238 + return nil, sql.ErrNoRows 239 239 + } 240 240 + 241 241 + return &discussions[0], nil 242 242 + } 243 243 + 244 244 + // GetDiscussions returns discussions matching filters 245 245 + func GetDiscussions(e Execer, filters ...orm.Filter) ([]models.Discussion, error) { 246 246 + return GetDiscussionsPaginated(e, pagination.Page{}, filters...) 247 247 + } 248 248 + 249 249 + // AddDiscussionPatch adds a patch to a discussion 250 250 + // Anyone can add patches - the key feature of the Nest model 251 251 + func AddDiscussionPatch(tx *sql.Tx, patch *models.DiscussionPatch) error { 252 252 + row := tx.QueryRow(` 253 253 + insert into discussion_patches (discussion_at, pushed_by_did, patch_hash, patch) 254 254 + values (?, ?, ?, ?) 255 255 + returning id 256 256 + `, patch.DiscussionAt, patch.PushedByDid, patch.PatchHash, patch.Patch) 257 257 + 258 258 + return row.Scan(&patch.Id) 259 259 + } 260 260 + 261 261 + // PatchExists checks if a patch with the given hash already exists in the discussion 262 262 + func PatchExists(e Execer, discussionAt syntax.ATURI, patchHash string) (bool, error) { 263 263 + var count int 264 264 + err := e.QueryRow(` 265 265 + select count(1) from discussion_patches 266 266 + where discussion_at = ? and patch_hash = ? 267 267 + `, discussionAt, patchHash).Scan(&count) 268 268 + if err != nil { 269 269 + return false, err 270 270 + } 271 271 + return count > 0, nil 272 272 + } 273 273 + 274 274 + // RemovePatch marks a patch as removed (soft delete) 275 275 + func RemovePatch(e Execer, patchId int64) error { 276 276 + _, err := e.Exec(` 277 277 + update discussion_patches 278 278 + set removed = strftime('%Y-%m-%dT%H:%M:%SZ', 'now') 279 279 + where id = ? 280 280 + `, patchId) 281 281 + return err 282 282 + } 283 283 + 284 284 + // ReaddPatch re-adds a previously removed patch 285 285 + func ReaddPatch(e Execer, patchId int64) error { 286 286 + _, err := e.Exec(` 287 287 + update discussion_patches 288 288 + set removed = null 289 289 + where id = ? 290 290 + `, patchId) 291 291 + return err 292 292 + } 293 293 + 294 294 + // GetDiscussionPatches returns patches for discussions 295 295 + func GetDiscussionPatches(e Execer, filters ...orm.Filter) ([]*models.DiscussionPatch, error) { 296 296 + var conditions []string 297 297 + var args []any 298 298 + for _, filter := range filters { 299 299 + conditions = append(conditions, filter.Condition()) 300 300 + args = append(args, filter.Arg()...) 301 301 + } 302 302 + 303 303 + whereClause := "" 304 304 + if conditions != nil { 305 305 + whereClause = " where " + strings.Join(conditions, " and ") 306 306 + } 307 307 + 308 308 + query := fmt.Sprintf(` 309 309 + select 310 310 + id, 311 311 + discussion_at, 312 312 + pushed_by_did, 313 313 + patch_hash, 314 314 + patch, 315 315 + added, 316 316 + removed 317 317 + from 318 318 + discussion_patches 319 319 + %s 320 320 + order by added asc 321 321 + `, whereClause) 322 322 + 323 323 + rows, err := e.Query(query, args...) 324 324 + if err != nil { 325 325 + return nil, err 326 326 + } 327 327 + defer rows.Close() 328 328 + 329 329 + var patches []*models.DiscussionPatch 330 330 + for rows.Next() { 331 331 + var patch models.DiscussionPatch 332 332 + var addedAt string 333 333 + var removedAt sql.Null[string] 334 334 + err := rows.Scan( 335 335 + &patch.Id, 336 336 + &patch.DiscussionAt, 337 337 + &patch.PushedByDid, 338 338 + &patch.PatchHash, 339 339 + &patch.Patch, 340 340 + &addedAt, 341 341 + &removedAt, 342 342 + ) 343 343 + if err != nil { 344 344 + return nil, err 345 345 + } 346 346 + 347 347 + if t, err := time.Parse(time.RFC3339, addedAt); err == nil { 348 348 + patch.Added = t 349 349 + } 350 350 + 351 351 + if removedAt.Valid { 352 352 + if t, err := time.Parse(time.RFC3339, removedAt.V); err == nil { 353 353 + patch.Removed = &t 354 354 + } 355 355 + } 356 356 + 357 357 + patches = append(patches, &patch) 358 358 + } 359 359 + 360 360 + if err = rows.Err(); err != nil { 361 361 + return nil, err 362 362 + } 363 363 + 364 364 + return patches, nil 365 365 + } 366 366 + 367 367 + // GetDiscussionPatch returns a single patch by ID 368 368 + func GetDiscussionPatch(e Execer, patchId int64) (*models.DiscussionPatch, error) { 369 369 + patches, err := GetDiscussionPatches(e, orm.FilterEq("id", patchId)) 370 370 + if err != nil { 371 371 + return nil, err 372 372 + } 373 373 + if len(patches) != 1 { 374 374 + return nil, sql.ErrNoRows 375 375 + } 376 376 + return patches[0], nil 377 377 + } 378 378 + 379 379 + // AddDiscussionComment adds a comment to a discussion 380 380 + func AddDiscussionComment(tx *sql.Tx, c models.DiscussionComment) (int64, error) { 381 381 + result, err := tx.Exec( 382 382 + `insert into discussion_comments ( 383 383 + did, 384 384 + rkey, 385 385 + discussion_at, 386 386 + body, 387 387 + reply_to, 388 388 + created, 389 389 + edited 390 390 + ) 391 391 + values (?, ?, ?, ?, ?, ?, null) 392 392 + on conflict(did, rkey) do update set 393 393 + discussion_at = excluded.discussion_at, 394 394 + body = excluded.body, 395 395 + edited = case 396 396 + when 397 397 + discussion_comments.discussion_at != excluded.discussion_at 398 398 + or discussion_comments.body != excluded.body 399 399 + or discussion_comments.reply_to != excluded.reply_to 400 400 + then ? 401 401 + else discussion_comments.edited 402 402 + end`, 403 403 + c.Did, 404 404 + c.Rkey, 405 405 + c.DiscussionAt, 406 406 + c.Body, 407 407 + c.ReplyTo, 408 408 + c.Created.Format(time.RFC3339), 409 409 + time.Now().Format(time.RFC3339), 410 410 + ) 411 411 + if err != nil { 412 412 + return 0, err 413 413 + } 414 414 + 415 415 + id, err := result.LastInsertId() 416 416 + if err != nil { 417 417 + return 0, err 418 418 + } 419 419 + 420 420 + return id, nil 421 421 + } 422 422 + 423 423 + // GetDiscussionComments returns comments for discussions 424 424 + func GetDiscussionComments(e Execer, filters ...orm.Filter) ([]models.DiscussionComment, error) { 425 425 + var conditions []string 426 426 + var args []any 427 427 + for _, filter := range filters { 428 428 + conditions = append(conditions, filter.Condition()) 429 429 + args = append(args, filter.Arg()...) 430 430 + } 431 431 + 432 432 + whereClause := "" 433 433 + if conditions != nil { 434 434 + whereClause = " where " + strings.Join(conditions, " and ") 435 435 + } 436 436 + 437 437 + query := fmt.Sprintf(` 438 438 + select 439 439 + id, 440 440 + did, 441 441 + rkey, 442 442 + discussion_at, 443 443 + reply_to, 444 444 + body, 445 445 + created, 446 446 + edited, 447 447 + deleted 448 448 + from 449 449 + discussion_comments 450 450 + %s 451 451 + order by created asc 452 452 + `, whereClause) 453 453 + 454 454 + rows, err := e.Query(query, args...) 455 455 + if err != nil { 456 456 + return nil, err 457 457 + } 458 458 + defer rows.Close() 459 459 + 460 460 + var comments []models.DiscussionComment 461 461 + for rows.Next() { 462 462 + var comment models.DiscussionComment 463 463 + var created string 464 464 + var rkey, edited, deleted, replyTo sql.Null[string] 465 465 + err := rows.Scan( 466 466 + &comment.Id, 467 467 + &comment.Did, 468 468 + &rkey, 469 469 + &comment.DiscussionAt, 470 470 + &replyTo, 471 471 + &comment.Body, 472 472 + &created, 473 473 + &edited, 474 474 + &deleted, 475 475 + ) 476 476 + if err != nil { 477 477 + return nil, err 478 478 + } 479 479 + 480 480 + if rkey.Valid { 481 481 + comment.Rkey = rkey.V 482 482 + } 483 483 + 484 484 + if t, err := time.Parse(time.RFC3339, created); err == nil { 485 485 + comment.Created = t 486 486 + } 487 487 + 488 488 + if edited.Valid { 489 489 + if t, err := time.Parse(time.RFC3339, edited.V); err == nil { 490 490 + comment.Edited = &t 491 491 + } 492 492 + } 493 493 + 494 494 + if deleted.Valid { 495 495 + if t, err := time.Parse(time.RFC3339, deleted.V); err == nil { 496 496 + comment.Deleted = &t 497 497 + } 498 498 + } 499 499 + 500 500 + if replyTo.Valid { 501 501 + comment.ReplyTo = &replyTo.V 502 502 + } 503 503 + 504 504 + comments = append(comments, comment) 505 505 + } 506 506 + 507 507 + if err = rows.Err(); err != nil { 508 508 + return nil, err 509 509 + } 510 510 + 511 511 + return comments, nil 512 512 + } 513 513 + 514 514 + // DeleteDiscussionComment soft-deletes a comment 515 515 + func DeleteDiscussionComment(e Execer, filters ...orm.Filter) error { 516 516 + var conditions []string 517 517 + var args []any 518 518 + for _, filter := range filters { 519 519 + conditions = append(conditions, filter.Condition()) 520 520 + args = append(args, filter.Arg()...) 521 521 + } 522 522 + 523 523 + whereClause := "" 524 524 + if conditions != nil { 525 525 + whereClause = " where " + strings.Join(conditions, " and ") 526 526 + } 527 527 + 528 528 + query := fmt.Sprintf(`update discussion_comments set body = "", deleted = strftime('%%Y-%%m-%%dT%%H:%%M:%%SZ', 'now') %s`, whereClause) 529 529 + 530 530 + _, err := e.Exec(query, args...) 531 531 + return err 532 532 + } 533 533 + 534 534 + // CloseDiscussion closes a discussion 535 535 + func CloseDiscussion(e Execer, repoAt syntax.ATURI, discussionId int) error { 536 536 + _, err := e.Exec(` 537 537 + update discussions set state = ? 538 538 + where repo_at = ? and discussion_id = ? 539 539 + `, models.DiscussionClosed, repoAt, discussionId) 540 540 + return err 541 541 + } 542 542 + 543 543 + // ReopenDiscussion reopens a discussion 544 544 + func ReopenDiscussion(e Execer, repoAt syntax.ATURI, discussionId int) error { 545 545 + _, err := e.Exec(` 546 546 + update discussions set state = ? 547 547 + where repo_at = ? and discussion_id = ? 548 548 + `, models.DiscussionOpen, repoAt, discussionId) 549 549 + return err 550 550 + } 551 551 + 552 552 + // MergeDiscussion marks a discussion as merged 553 553 + func MergeDiscussion(e Execer, repoAt syntax.ATURI, discussionId int) error { 554 554 + _, err := e.Exec(` 555 555 + update discussions set state = ? 556 556 + where repo_at = ? and discussion_id = ? 557 557 + `, models.DiscussionMerged, repoAt, discussionId) 558 558 + return err 559 559 + } 560 560 + 561 561 + // SetDiscussionState sets the state of a discussion 562 562 + func SetDiscussionState(e Execer, repoAt syntax.ATURI, discussionId int, state models.DiscussionState) error { 563 563 + _, err := e.Exec(` 564 564 + update discussions set state = ? 565 565 + where repo_at = ? and discussion_id = ? 566 566 + `, state, repoAt, discussionId) 567 567 + return err 568 568 + } 569 569 + 570 570 + // GetDiscussionCount returns counts of discussions by state 571 571 + func GetDiscussionCount(e Execer, repoAt syntax.ATURI) (models.DiscussionCount, error) { 572 572 + row := e.QueryRow(` 573 573 + select 574 574 + count(case when state = ? then 1 end) as open_count, 575 575 + count(case when state = ? then 1 end) as merged_count, 576 576 + count(case when state = ? then 1 end) as closed_count 577 577 + from discussions 578 578 + where repo_at = ?`, 579 579 + models.DiscussionOpen, 580 580 + models.DiscussionMerged, 581 581 + models.DiscussionClosed, 582 582 + repoAt, 583 583 + ) 584 584 + 585 585 + var count models.DiscussionCount 586 586 + if err := row.Scan(&count.Open, &count.Merged, &count.Closed); err != nil { 587 587 + return models.DiscussionCount{}, err 588 588 + } 589 589 + 590 590 + return count, nil 591 591 + } 592 592 + 593 593 + // SubscribeToDiscussion adds a subscription for a user to a discussion 594 594 + func SubscribeToDiscussion(e Execer, discussionAt syntax.ATURI, subscriberDid string) error { 595 595 + _, err := e.Exec(` 596 596 + insert or ignore into discussion_subscriptions (discussion_at, subscriber_did) 597 597 + values (?, ?) 598 598 + `, discussionAt, subscriberDid) 599 599 + return err 600 600 + } 601 601 + 602 602 + // UnsubscribeFromDiscussion removes a subscription 603 603 + func UnsubscribeFromDiscussion(e Execer, discussionAt syntax.ATURI, subscriberDid string) error { 604 604 + _, err := e.Exec(` 605 605 + delete from discussion_subscriptions 606 606 + where discussion_at = ? and subscriber_did = ? 607 607 + `, discussionAt, subscriberDid) 608 608 + return err 609 609 + } 610 610 + 611 611 + // GetDiscussionSubscribers returns all subscribers for a discussion 612 612 + func GetDiscussionSubscribers(e Execer, discussionAt syntax.ATURI) ([]string, error) { 613 613 + rows, err := e.Query(` 614 614 + select subscriber_did from discussion_subscriptions 615 615 + where discussion_at = ? 616 616 + `, discussionAt) 617 617 + if err != nil { 618 618 + return nil, err 619 619 + } 620 620 + defer rows.Close() 621 621 + 622 622 + var subscribers []string 623 623 + for rows.Next() { 624 624 + var did string 625 625 + if err := rows.Scan(&did); err != nil { 626 626 + return nil, err 627 627 + } 628 628 + subscribers = append(subscribers, did) 629 629 + } 630 630 + 631 631 + return subscribers, rows.Err() 632 632 + }

+26 -8

appview/db/repos.go

reviewed

··· 51 51 topics, 52 52 source, 53 53 spindle, 54 54 - repo_did 55 55 - from repos 54 54 + repo_did, 55 55 + vcs 56 56 + from 57 57 + repos 56 58 %s 57 59 order by created desc 58 60 %s ··· 68 70 for rows.Next() { 69 71 var repo models.Repo 70 72 var createdAt string 71 71 - var description, website, topicStr, source, spindle, repoDid sql.NullString 73 73 + var description, website, topicStr, source, spindle, repoDid, vcs sql.NullString 72 74 73 75 err := rows.Scan( 74 76 &repo.Id, ··· 83 85 &source, 84 86 &spindle, 85 87 &repoDid, 88 88 + &vcs, 86 89 ) 87 90 if err != nil { 88 91 return nil, err ··· 111 114 } 112 115 if repoDid.Valid { 113 116 repo.RepoDid = repoDid.String 117 117 + } 118 118 + if vcs.Valid { 119 119 + repo.Vcs = vcs.String 120 120 + } else { 121 121 + repo.Vcs = "git" // default 114 122 } 115 123 116 124 repo.RepoStats = &models.RepoStats{} ··· 365 373 var nullableRepoDid sql.NullString 366 374 var nullableSource sql.NullString 367 375 var nullableSpindle sql.NullString 376 376 + var nullableVcs sql.NullString 368 377 369 369 - row := e.QueryRow(`select id, did, name, knot, created, rkey, description, website, topics, source, spindle, repo_did from repos where at_uri = ?`, atUri) 378 378 + row := e.QueryRow(`select id, did, name, knot, created, rkey, description, website, topics, source, spindle, repo_did, vcs from repos where at_uri = ?`, atUri) 370 379 371 380 var createdAt string 372 372 - if err := row.Scan(&repo.Id, &repo.Did, &repo.Name, &repo.Knot, &createdAt, &repo.Rkey, &nullableDescription, &nullableWebsite, &nullableTopicStr, &nullableSource, &nullableSpindle, &nullableRepoDid); err != nil { 381 381 + if err := row.Scan(&repo.Id, &repo.Did, &repo.Name, &repo.Knot, &createdAt, &repo.Rkey, &nullableDescription, &nullableWebsite, &nullableTopicStr, &nullableSource, &nullableSpindle, &nullableRepoDid, &nullableVcs); err != nil { 373 382 return nil, err 374 383 } 375 384 createdAtTime, _ := time.Parse(time.RFC3339, createdAt) ··· 392 401 } 393 402 if nullableRepoDid.Valid { 394 403 repo.RepoDid = nullableRepoDid.String 404 404 + } 405 405 + if nullableVcs.Valid { 406 406 + repo.Vcs = nullableVcs.String 407 407 + } else { 408 408 + repo.Vcs = "git" 395 409 } 396 410 397 411 return &repo, nil ··· 417 431 if repo.RepoDid != "" { 418 432 repoDid = &repo.RepoDid 419 433 } 434 434 + vcs := repo.Vcs 435 435 + if vcs == "" { 436 436 + vcs = "git" 437 437 + } 420 438 _, err := tx.Exec( 421 439 `insert into repos 422 422 - (did, name, knot, rkey, at_uri, description, website, topics, source, repo_did) 423 423 - values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, 424 424 - repo.Did, repo.Name, repo.Knot, repo.Rkey, repo.RepoAt().String(), repo.Description, repo.Website, repo.TopicStr(), repo.Source, repoDid, 440 440 + (did, name, knot, rkey, at_uri, description, website, topics, source, repo_did, vcs) 441 441 + values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, 442 442 + repo.Did, repo.Name, repo.Knot, repo.Rkey, repo.RepoAt().String(), repo.Description, repo.Website, repo.TopicStr(), repo.Source, repoDid, vcs, 425 443 ) 426 444 if err != nil { 427 445 return fmt.Errorf("failed to insert repo: %w", err)

+800

appview/discussions/discussions.go

reviewed

··· 1 1 + package discussions 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "fmt" 6 6 + "log/slog" 7 7 + "net/http" 8 8 + "strconv" 9 9 + "time" 10 10 + 11 11 + comatproto "github.com/bluesky-social/indigo/api/atproto" 12 12 + "github.com/bluesky-social/indigo/xrpc" 13 13 + "github.com/go-chi/chi/v5" 14 14 + lexutil "github.com/bluesky-social/indigo/lex/util" 15 15 + 16 16 + tangled "tangled.org/core/api/tangled" 17 17 + "tangled.org/core/appview/config" 18 18 + "tangled.org/core/appview/db" 19 19 + "tangled.org/core/appview/mentions" 20 20 + "tangled.org/core/appview/models" 21 21 + "tangled.org/core/appview/notify" 22 22 + "tangled.org/core/appview/oauth" 23 23 + "tangled.org/core/appview/pages" 24 24 + "tangled.org/core/appview/pages/repoinfo" 25 25 + "tangled.org/core/appview/pagination" 26 26 + "tangled.org/core/appview/reporesolver" 27 27 + "tangled.org/core/appview/validator" 28 28 + "tangled.org/core/idresolver" 29 29 + "tangled.org/core/orm" 30 30 + "tangled.org/core/rbac" 31 31 + "tangled.org/core/tid" 32 32 + ) 33 33 + 34 34 + // Discussions handles the discussions feature for Pijul repositories 35 35 + type Discussions struct { 36 36 + oauth *oauth.OAuth 37 37 + repoResolver *reporesolver.RepoResolver 38 38 + enforcer *rbac.Enforcer 39 39 + pages *pages.Pages 40 40 + idResolver *idresolver.Resolver 41 41 + mentionsResolver *mentions.Resolver 42 42 + db *db.DB 43 43 + config *config.Config 44 44 + notifier notify.Notifier 45 45 + logger *slog.Logger 46 46 + validator *validator.Validator 47 47 + } 48 48 + 49 49 + func New( 50 50 + oauth *oauth.OAuth, 51 51 + repoResolver *reporesolver.RepoResolver, 52 52 + enforcer *rbac.Enforcer, 53 53 + pages *pages.Pages, 54 54 + idResolver *idresolver.Resolver, 55 55 + mentionsResolver *mentions.Resolver, 56 56 + db *db.DB, 57 57 + config *config.Config, 58 58 + notifier notify.Notifier, 59 59 + validator *validator.Validator, 60 60 + logger *slog.Logger, 61 61 + ) *Discussions { 62 62 + return &Discussions{ 63 63 + oauth: oauth, 64 64 + repoResolver: repoResolver, 65 65 + enforcer: enforcer, 66 66 + pages: pages, 67 67 + idResolver: idResolver, 68 68 + mentionsResolver: mentionsResolver, 69 69 + db: db, 70 70 + config: config, 71 71 + notifier: notifier, 72 72 + logger: logger, 73 73 + validator: validator, 74 74 + } 75 75 + } 76 76 + 77 77 + // rolesFor returns the RolesInRepo for the given user in the repo described by repoInfo. 78 78 + // rolesFor returns the RolesInRepo for the given user in the repo described by repoInfo. 79 79 + func (d *Discussions) rolesFor(userDid string, ri repoinfo.RepoInfo) repoinfo.RolesInRepo { 80 80 + return repoinfo.RolesInRepo{ 81 81 + Roles: d.enforcer.GetPermissionsInRepo(userDid, ri.Knot, ri.OwnerDid+"/"+ri.Name), 82 82 + } 83 83 + } 84 84 + 85 85 + // RepoDiscussionsList shows all discussions for a Pijul repository 86 86 + func (d *Discussions) RepoDiscussionsList(w http.ResponseWriter, r *http.Request) { 87 87 + l := d.logger.With("handler", "RepoDiscussionsList") 88 88 + user := d.oauth.GetMultiAccountUser(r) 89 89 + 90 90 + repo, err := d.repoResolver.Resolve(r) 91 91 + if err != nil { 92 92 + l.Error("failed to get repo", "err", err) 93 93 + d.pages.Error404(w) 94 94 + return 95 95 + } 96 96 + 97 97 + // Only allow discussions for Pijul repos 98 98 + if !repo.IsPijul() { 99 99 + l.Info("discussions only available for pijul repos") 100 100 + d.pages.Error404(w) 101 101 + return 102 102 + } 103 103 + 104 104 + repoAt := repo.RepoAt() 105 105 + page := pagination.Page{Limit: 50} 106 106 + 107 107 + // Filter by state 108 108 + filter := r.URL.Query().Get("filter") 109 109 + filters := []orm.Filter{orm.FilterEq("repo_at", repoAt)} 110 110 + switch filter { 111 111 + case "closed": 112 112 + filters = append(filters, orm.FilterEq("state", models.DiscussionClosed)) 113 113 + case "merged": 114 114 + filters = append(filters, orm.FilterEq("state", models.DiscussionMerged)) 115 115 + default: 116 116 + // Default to open 117 117 + filters = append(filters, orm.FilterEq("state", models.DiscussionOpen)) 118 118 + filter = "open" 119 119 + } 120 120 + 121 121 + discussions, err := db.GetDiscussionsPaginated(d.db, page, filters...) 122 122 + if err != nil { 123 123 + l.Error("failed to fetch discussions", "err", err) 124 124 + d.pages.Error503(w) 125 125 + return 126 126 + } 127 127 + 128 128 + count, err := db.GetDiscussionCount(d.db, repoAt) 129 129 + if err != nil { 130 130 + l.Error("failed to get discussion count", "err", err) 131 131 + } 132 132 + 133 133 + d.pages.RepoDiscussionsList(w, pages.RepoDiscussionsListParams{ 134 134 + LoggedInUser: user, 135 135 + RepoInfo: d.repoResolver.GetRepoInfo(r, user), 136 136 + Discussions: discussions, 137 137 + Filter: filter, 138 138 + DiscussionCount: count, 139 139 + }) 140 140 + } 141 141 + 142 142 + // NewDiscussion creates a new discussion 143 143 + func (d *Discussions) NewDiscussion(w http.ResponseWriter, r *http.Request) { 144 144 + l := d.logger.With("handler", "NewDiscussion") 145 145 + user := d.oauth.GetMultiAccountUser(r) 146 146 + 147 147 + repo, err := d.repoResolver.Resolve(r) 148 148 + if err != nil { 149 149 + l.Error("failed to get repo", "err", err) 150 150 + d.pages.Error404(w) 151 151 + return 152 152 + } 153 153 + 154 154 + if !repo.IsPijul() { 155 155 + l.Info("discussions only available for pijul repos") 156 156 + d.pages.Error404(w) 157 157 + return 158 158 + } 159 159 + 160 160 + repoInfo := d.repoResolver.GetRepoInfo(r, user) 161 161 + 162 162 + switch r.Method { 163 163 + case http.MethodGet: 164 164 + d.pages.NewDiscussion(w, pages.NewDiscussionParams{ 165 165 + LoggedInUser: user, 166 166 + RepoInfo: repoInfo, 167 167 + }) 168 168 + 169 169 + case http.MethodPost: 170 170 + noticeId := "discussion" 171 171 + 172 172 + title := r.FormValue("title") 173 173 + body := r.FormValue("body") 174 174 + targetChannel := r.FormValue("target_channel") 175 175 + if targetChannel == "" { 176 176 + targetChannel = "main" 177 177 + } 178 178 + 179 179 + if title == "" { 180 180 + d.pages.Notice(w, noticeId, "Title is required") 181 181 + return 182 182 + } 183 183 + 184 184 + discussion := &models.Discussion{ 185 185 + Did: user.Active.Did, 186 186 + Rkey: tid.TID(), 187 187 + RepoAt: repo.RepoAt(), 188 188 + Title: title, 189 189 + Body: body, 190 190 + TargetChannel: targetChannel, 191 191 + State: models.DiscussionOpen, 192 192 + Created: time.Now(), 193 193 + } 194 194 + 195 195 + tx, err := d.db.BeginTx(r.Context(), nil) 196 196 + if err != nil { 197 197 + l.Error("failed to begin transaction", "err", err) 198 198 + d.pages.Notice(w, noticeId, "Failed to create discussion") 199 199 + return 200 200 + } 201 201 + defer tx.Rollback() 202 202 + 203 203 + if err := db.NewDiscussion(tx, discussion); err != nil { 204 204 + l.Error("failed to create discussion", "err", err) 205 205 + d.pages.Notice(w, noticeId, "Failed to create discussion") 206 206 + return 207 207 + } 208 208 + 209 209 + if err := tx.Commit(); err != nil { 210 210 + l.Error("failed to commit transaction", "err", err) 211 211 + d.pages.Notice(w, noticeId, "Failed to create discussion") 212 212 + return 213 213 + } 214 214 + 215 215 + // Subscribe the creator to the discussion 216 216 + db.SubscribeToDiscussion(d.db, discussion.AtUri(), user.Active.Did) 217 217 + 218 218 + l.Info("discussion created", "discussion_id", discussion.DiscussionId) 219 219 + 220 220 + d.pages.HxLocation(w, fmt.Sprintf("/%s/%s/discussions/%d", 221 221 + repo.Did, repo.Name, discussion.DiscussionId)) 222 222 + } 223 223 + } 224 224 + 225 225 + // RepoSingleDiscussion shows a single discussion 226 226 + func (d *Discussions) RepoSingleDiscussion(w http.ResponseWriter, r *http.Request) { 227 227 + l := d.logger.With("handler", "RepoSingleDiscussion") 228 228 + user := d.oauth.GetMultiAccountUser(r) 229 229 + 230 230 + discussion, ok := r.Context().Value("discussion").(*models.Discussion) 231 231 + if !ok { 232 232 + l.Error("failed to get discussion from context") 233 233 + d.pages.Error404(w) 234 234 + return 235 235 + } 236 236 + 237 237 + repoInfo := d.repoResolver.GetRepoInfo(r, user) 238 238 + 239 239 + canManage := user != nil && d.rolesFor(user.Active.Did, repoInfo).CanManageRepo() 240 240 + 241 241 + d.pages.RepoSingleDiscussion(w, pages.RepoSingleDiscussionParams{ 242 242 + LoggedInUser: user, 243 243 + RepoInfo: repoInfo, 244 244 + Discussion: discussion, 245 245 + CommentList: discussion.CommentList(), 246 246 + CanManage: canManage, 247 247 + ActivePatches: discussion.ActivePatches(), 248 248 + }) 249 249 + } 250 250 + 251 251 + // AddPatch allows anyone to add a patch to a discussion 252 252 + func (d *Discussions) AddPatch(w http.ResponseWriter, r *http.Request) { 253 253 + l := d.logger.With("handler", "AddPatch") 254 254 + user := d.oauth.GetMultiAccountUser(r) 255 255 + noticeId := "patch" 256 256 + 257 257 + discussion, ok := r.Context().Value("discussion").(*models.Discussion) 258 258 + if !ok { 259 259 + l.Error("failed to get discussion from context") 260 260 + d.pages.Notice(w, noticeId, "Discussion not found") 261 261 + return 262 262 + } 263 263 + 264 264 + if discussion.State != models.DiscussionOpen { 265 265 + d.pages.Notice(w, noticeId, "Cannot add patches to a closed or merged discussion") 266 266 + return 267 267 + } 268 268 + 269 269 + patchHash := r.FormValue("patch_hash") 270 270 + patch := r.FormValue("patch") 271 271 + 272 272 + if patchHash == "" || patch == "" { 273 273 + d.pages.Notice(w, noticeId, "Patch hash and content are required") 274 274 + return 275 275 + } 276 276 + 277 277 + // Check if patch already exists 278 278 + exists, err := db.PatchExists(d.db, discussion.AtUri(), patchHash) 279 279 + if err != nil { 280 280 + l.Error("failed to check patch existence", "err", err) 281 281 + d.pages.Notice(w, noticeId, "Failed to add patch") 282 282 + return 283 283 + } 284 284 + if exists { 285 285 + d.pages.Notice(w, noticeId, "This patch has already been added to the discussion") 286 286 + return 287 287 + } 288 288 + 289 289 + // Get repo info for verification and dependency checking 290 290 + repo, err := d.repoResolver.Resolve(r) 291 291 + if err != nil { 292 292 + l.Error("failed to resolve repo", "err", err) 293 293 + d.pages.Notice(w, noticeId, "Failed to add patch") 294 294 + return 295 295 + } 296 296 + 297 297 + repoIdentifier := fmt.Sprintf("%s/%s", repo.Did, repo.Name) 298 298 + 299 299 + // Verify the change exists in the Pijul repository 300 300 + change, err := d.getChangeFromKnot(r.Context(), repo.Knot, repoIdentifier, patchHash) 301 301 + if err != nil { 302 302 + l.Info("change verification failed", "hash", patchHash, "err", err) 303 303 + d.pages.Notice(w, noticeId, "Change not found in repository. Please ensure the change hash is correct and exists in the repo.") 304 304 + return 305 305 + } 306 306 + 307 307 + l.Debug("change verified", "hash", patchHash, "message", change.Message) 308 308 + 309 309 + // Check dependencies - ensure the patch doesn't depend on removed patches 310 310 + if err := d.canAddPatchWithChange(discussion, change); err != nil { 311 311 + l.Info("dependency check failed", "err", err) 312 312 + d.pages.Notice(w, noticeId, err.Error()) 313 313 + return 314 314 + } 315 315 + 316 316 + discussionPatch := &models.DiscussionPatch{ 317 317 + DiscussionAt: discussion.AtUri(), 318 318 + PushedByDid: user.Active.Did, 319 319 + PatchHash: patchHash, 320 320 + Patch: patch, 321 321 + Added: time.Now(), 322 322 + } 323 323 + 324 324 + tx, err := d.db.BeginTx(r.Context(), nil) 325 325 + if err != nil { 326 326 + l.Error("failed to begin transaction", "err", err) 327 327 + d.pages.Notice(w, noticeId, "Failed to add patch") 328 328 + return 329 329 + } 330 330 + defer tx.Rollback() 331 331 + 332 332 + if err := db.AddDiscussionPatch(tx, discussionPatch); err != nil { 333 333 + l.Error("failed to add patch", "err", err) 334 334 + d.pages.Notice(w, noticeId, "Failed to add patch") 335 335 + return 336 336 + } 337 337 + 338 338 + if err := tx.Commit(); err != nil { 339 339 + l.Error("failed to commit transaction", "err", err) 340 340 + d.pages.Notice(w, noticeId, "Failed to add patch") 341 341 + return 342 342 + } 343 343 + 344 344 + // Subscribe the patch contributor to the discussion 345 345 + db.SubscribeToDiscussion(d.db, discussion.AtUri(), user.Active.Did) 346 346 + 347 347 + l.Info("patch added", "patch_hash", patchHash, "pushed_by", user.Active.Did) 348 348 + 349 349 + // Reload the page to show the new patch 350 350 + d.pages.HxLocation(w, fmt.Sprintf("/%s/%s/discussions/%d", 351 351 + repo.Did, repo.Name, discussion.DiscussionId)) 352 352 + } 353 353 + 354 354 + // RemovePatch removes a patch from a discussion (soft delete) 355 355 + func (d *Discussions) RemovePatch(w http.ResponseWriter, r *http.Request) { 356 356 + l := d.logger.With("handler", "RemovePatch") 357 357 + user := d.oauth.GetMultiAccountUser(r) 358 358 + noticeId := "patch" 359 359 + 360 360 + discussion, ok := r.Context().Value("discussion").(*models.Discussion) 361 361 + if !ok { 362 362 + l.Error("failed to get discussion from context") 363 363 + d.pages.Notice(w, noticeId, "Discussion not found") 364 364 + return 365 365 + } 366 366 + 367 367 + patchIdStr := chi.URLParam(r, "patchId") 368 368 + patchId, err := strconv.ParseInt(patchIdStr, 10, 64) 369 369 + if err != nil { 370 370 + d.pages.Notice(w, noticeId, "Invalid patch ID") 371 371 + return 372 372 + } 373 373 + 374 374 + patch, err := db.GetDiscussionPatch(d.db, patchId) 375 375 + if err != nil { 376 376 + l.Error("failed to get patch", "err", err) 377 377 + d.pages.Notice(w, noticeId, "Patch not found") 378 378 + return 379 379 + } 380 380 + 381 381 + // Check permission: patch pusher or repo collaborator 382 382 + repoInfo := d.repoResolver.GetRepoInfo(r, user) 383 383 + if patch.PushedByDid != user.Active.Did && !d.rolesFor(user.Active.Did, repoInfo).CanManageRepo() { 384 384 + d.pages.Notice(w, noticeId, "You don't have permission to remove this patch") 385 385 + return 386 386 + } 387 387 + 388 388 + // Get repo for dependency checking 389 389 + repo, err := d.repoResolver.Resolve(r) 390 390 + if err != nil { 391 391 + l.Error("failed to resolve repo", "err", err) 392 392 + d.pages.Notice(w, noticeId, "Failed to remove patch") 393 393 + return 394 394 + } 395 395 + 396 396 + // Check if other active patches depend on this one 397 397 + repoIdentifier := fmt.Sprintf("%s/%s", repo.Did, repo.Name) 398 398 + if err := d.canRemovePatch(r.Context(), discussion, repo.Knot, repoIdentifier, patch.PatchHash); err != nil { 399 399 + l.Info("dependency check failed", "err", err) 400 400 + d.pages.Notice(w, noticeId, err.Error()) 401 401 + return 402 402 + } 403 403 + 404 404 + if err := db.RemovePatch(d.db, patchId); err != nil { 405 405 + l.Error("failed to remove patch", "err", err) 406 406 + d.pages.Notice(w, noticeId, "Failed to remove patch") 407 407 + return 408 408 + } 409 409 + 410 410 + l.Info("patch removed", "patch_id", patchId) 411 411 + 412 412 + d.pages.HxLocation(w, fmt.Sprintf("/%s/%s/discussions/%d", 413 413 + repo.Did, repo.Name, discussion.DiscussionId)) 414 414 + } 415 415 + 416 416 + // ReaddPatch re-adds a previously removed patch 417 417 + func (d *Discussions) ReaddPatch(w http.ResponseWriter, r *http.Request) { 418 418 + l := d.logger.With("handler", "ReaddPatch") 419 419 + user := d.oauth.GetMultiAccountUser(r) 420 420 + noticeId := "patch" 421 421 + 422 422 + discussion, ok := r.Context().Value("discussion").(*models.Discussion) 423 423 + if !ok { 424 424 + l.Error("failed to get discussion from context") 425 425 + d.pages.Notice(w, noticeId, "Discussion not found") 426 426 + return 427 427 + } 428 428 + 429 429 + patchIdStr := chi.URLParam(r, "patchId") 430 430 + patchId, err := strconv.ParseInt(patchIdStr, 10, 64) 431 431 + if err != nil { 432 432 + d.pages.Notice(w, noticeId, "Invalid patch ID") 433 433 + return 434 434 + } 435 435 + 436 436 + patch, err := db.GetDiscussionPatch(d.db, patchId) 437 437 + if err != nil { 438 438 + l.Error("failed to get patch", "err", err) 439 439 + d.pages.Notice(w, noticeId, "Patch not found") 440 440 + return 441 441 + } 442 442 + 443 443 + // Check permission 444 444 + repoInfo := d.repoResolver.GetRepoInfo(r, user) 445 445 + if patch.PushedByDid != user.Active.Did && !d.rolesFor(user.Active.Did, repoInfo).CanManageRepo() { 446 446 + d.pages.Notice(w, noticeId, "You don't have permission to re-add this patch") 447 447 + return 448 448 + } 449 449 + 450 450 + if err := db.ReaddPatch(d.db, patchId); err != nil { 451 451 + l.Error("failed to re-add patch", "err", err) 452 452 + d.pages.Notice(w, noticeId, "Failed to re-add patch") 453 453 + return 454 454 + } 455 455 + 456 456 + l.Info("patch re-added", "patch_id", patchId) 457 457 + 458 458 + repo, _ := d.repoResolver.Resolve(r) 459 459 + d.pages.HxLocation(w, fmt.Sprintf("/%s/%s/discussions/%d", 460 460 + repo.Did, repo.Name, discussion.DiscussionId)) 461 461 + } 462 462 + 463 463 + // NewComment adds a comment to a discussion 464 464 + func (d *Discussions) NewComment(w http.ResponseWriter, r *http.Request) { 465 465 + l := d.logger.With("handler", "NewComment") 466 466 + user := d.oauth.GetMultiAccountUser(r) 467 467 + noticeId := "comment" 468 468 + 469 469 + discussion, ok := r.Context().Value("discussion").(*models.Discussion) 470 470 + if !ok { 471 471 + l.Error("failed to get discussion from context") 472 472 + d.pages.Notice(w, noticeId, "Discussion not found") 473 473 + return 474 474 + } 475 475 + 476 476 + body := r.FormValue("body") 477 477 + replyTo := r.FormValue("reply_to") 478 478 + 479 479 + if body == "" { 480 480 + d.pages.Notice(w, noticeId, "Comment body is required") 481 481 + return 482 482 + } 483 483 + 484 484 + comment := models.DiscussionComment{ 485 485 + Did: user.Active.Did, 486 486 + Rkey: tid.TID(), 487 487 + DiscussionAt: discussion.AtUri().String(), 488 488 + Body: body, 489 489 + Created: time.Now(), 490 490 + } 491 491 + 492 492 + if replyTo != "" { 493 493 + comment.ReplyTo = &replyTo 494 494 + } 495 495 + 496 496 + tx, err := d.db.BeginTx(r.Context(), nil) 497 497 + if err != nil { 498 498 + l.Error("failed to begin transaction", "err", err) 499 499 + d.pages.Notice(w, noticeId, "Failed to add comment") 500 500 + return 501 501 + } 502 502 + defer tx.Rollback() 503 503 + 504 504 + if _, err := db.AddDiscussionComment(tx, comment); err != nil { 505 505 + l.Error("failed to add comment", "err", err) 506 506 + d.pages.Notice(w, noticeId, "Failed to add comment") 507 507 + return 508 508 + } 509 509 + 510 510 + if err := tx.Commit(); err != nil { 511 511 + l.Error("failed to commit transaction", "err", err) 512 512 + d.pages.Notice(w, noticeId, "Failed to add comment") 513 513 + return 514 514 + } 515 515 + 516 516 + // Subscribe the commenter to the discussion 517 517 + db.SubscribeToDiscussion(d.db, discussion.AtUri(), user.Active.Did) 518 518 + 519 519 + l.Info("comment added", "discussion_id", discussion.DiscussionId) 520 520 + 521 521 + repo, _ := d.repoResolver.Resolve(r) 522 522 + d.pages.HxLocation(w, fmt.Sprintf("/%s/%s/discussions/%d", 523 523 + repo.Did, repo.Name, discussion.DiscussionId)) 524 524 + } 525 525 + 526 526 + // CloseDiscussion closes a discussion 527 527 + func (d *Discussions) CloseDiscussion(w http.ResponseWriter, r *http.Request) { 528 528 + l := d.logger.With("handler", "CloseDiscussion") 529 529 + user := d.oauth.GetMultiAccountUser(r) 530 530 + noticeId := "discussion" 531 531 + 532 532 + discussion, ok := r.Context().Value("discussion").(*models.Discussion) 533 533 + if !ok { 534 534 + l.Error("failed to get discussion from context") 535 535 + d.pages.Notice(w, noticeId, "Discussion not found") 536 536 + return 537 537 + } 538 538 + 539 539 + // Check permission: discussion creator or repo manager 540 540 + repoInfo := d.repoResolver.GetRepoInfo(r, user) 541 541 + if discussion.Did != user.Active.Did && !d.rolesFor(user.Active.Did, repoInfo).CanManageRepo() { 542 542 + d.pages.Notice(w, noticeId, "You don't have permission to close this discussion") 543 543 + return 544 544 + } 545 545 + 546 546 + if err := db.CloseDiscussion(d.db, discussion.RepoAt, discussion.DiscussionId); err != nil { 547 547 + l.Error("failed to close discussion", "err", err) 548 548 + d.pages.Notice(w, noticeId, "Failed to close discussion") 549 549 + return 550 550 + } 551 551 + 552 552 + l.Info("discussion closed", "discussion_id", discussion.DiscussionId) 553 553 + 554 554 + repo, _ := d.repoResolver.Resolve(r) 555 555 + d.pages.HxLocation(w, fmt.Sprintf("/%s/%s/discussions/%d", 556 556 + repo.Did, repo.Name, discussion.DiscussionId)) 557 557 + } 558 558 + 559 559 + // ReopenDiscussion reopens a discussion 560 560 + func (d *Discussions) ReopenDiscussion(w http.ResponseWriter, r *http.Request) { 561 561 + l := d.logger.With("handler", "ReopenDiscussion") 562 562 + user := d.oauth.GetMultiAccountUser(r) 563 563 + noticeId := "discussion" 564 564 + 565 565 + discussion, ok := r.Context().Value("discussion").(*models.Discussion) 566 566 + if !ok { 567 567 + l.Error("failed to get discussion from context") 568 568 + d.pages.Notice(w, noticeId, "Discussion not found") 569 569 + return 570 570 + } 571 571 + 572 572 + // Check permission: discussion creator or repo manager 573 573 + repoInfo := d.repoResolver.GetRepoInfo(r, user) 574 574 + if discussion.Did != user.Active.Did && !d.rolesFor(user.Active.Did, repoInfo).CanManageRepo() { 575 575 + d.pages.Notice(w, noticeId, "You don't have permission to reopen this discussion") 576 576 + return 577 577 + } 578 578 + 579 579 + if err := db.ReopenDiscussion(d.db, discussion.RepoAt, discussion.DiscussionId); err != nil { 580 580 + l.Error("failed to reopen discussion", "err", err) 581 581 + d.pages.Notice(w, noticeId, "Failed to reopen discussion") 582 582 + return 583 583 + } 584 584 + 585 585 + l.Info("discussion reopened", "discussion_id", discussion.DiscussionId) 586 586 + 587 587 + repo, _ := d.repoResolver.Resolve(r) 588 588 + d.pages.HxLocation(w, fmt.Sprintf("/%s/%s/discussions/%d", 589 589 + repo.Did, repo.Name, discussion.DiscussionId)) 590 590 + } 591 591 + 592 592 + // MergeDiscussion applies patches and marks a discussion as merged 593 593 + func (d *Discussions) MergeDiscussion(w http.ResponseWriter, r *http.Request) { 594 594 + l := d.logger.With("handler", "MergeDiscussion") 595 595 + user := d.oauth.GetMultiAccountUser(r) 596 596 + noticeId := "discussion" 597 597 + 598 598 + discussion, ok := r.Context().Value("discussion").(*models.Discussion) 599 599 + if !ok { 600 600 + l.Error("failed to get discussion from context") 601 601 + d.pages.Notice(w, noticeId, "Discussion not found") 602 602 + return 603 603 + } 604 604 + 605 605 + // Only collaborators can merge 606 606 + repoInfo := d.repoResolver.GetRepoInfo(r, user) 607 607 + if !d.rolesFor(user.Active.Did, repoInfo).CanManageRepo() { 608 608 + d.pages.Notice(w, noticeId, "You don't have permission to merge this discussion") 609 609 + return 610 610 + } 611 611 + 612 612 + // Get all active patches to apply 613 613 + activePatches := discussion.ActivePatches() 614 614 + if len(activePatches) == 0 { 615 615 + d.pages.Notice(w, noticeId, "No patches to merge") 616 616 + return 617 617 + } 618 618 + 619 619 + // Get repo for API call 620 620 + repo, err := d.repoResolver.Resolve(r) 621 621 + if err != nil { 622 622 + l.Error("failed to resolve repo", "err", err) 623 623 + d.pages.Notice(w, noticeId, "Failed to merge discussion") 624 624 + return 625 625 + } 626 626 + 627 627 + // Apply patches via knotserver (needs authenticated client since endpoint requires service auth) 628 628 + xrpcc, err := d.oauth.ServiceClient( 629 629 + r, 630 630 + oauth.WithService(repo.Knot), 631 631 + oauth.WithLxm(tangled.RepoApplyChangesNSID), 632 632 + oauth.WithDev(d.config.Core.Dev), 633 633 + ) 634 634 + if err != nil { 635 635 + l.Error("failed to create service client", "err", err) 636 636 + d.pages.Notice(w, noticeId, "Failed to authenticate with knotserver") 637 637 + return 638 638 + } 639 639 + 640 640 + // Collect patch hashes in order 641 641 + changeHashes := make([]string, len(activePatches)) 642 642 + for i, patch := range activePatches { 643 643 + changeHashes[i] = patch.PatchHash 644 644 + } 645 645 + 646 646 + repoIdentifier := fmt.Sprintf("%s/%s", repo.Did, repo.Name) 647 647 + applyInput := &tangled.RepoApplyChanges_Input{ 648 648 + Repo: repoIdentifier, 649 649 + Channel: discussion.TargetChannel, 650 650 + Changes: changeHashes, 651 651 + } 652 652 + 653 653 + applyResult, err := tangled.RepoApplyChanges(r.Context(), xrpcc, applyInput) 654 654 + if err != nil { 655 655 + l.Error("failed to apply changes", "err", err) 656 656 + d.pages.Notice(w, noticeId, "Failed to apply patches: "+err.Error()) 657 657 + return 658 658 + } 659 659 + 660 660 + // Check if all patches were applied 661 661 + if len(applyResult.Failed) > 0 { 662 662 + failedHashes := make([]string, len(applyResult.Failed)) 663 663 + for i, f := range applyResult.Failed { 664 664 + failedHashes[i] = f.Hash[:12] 665 665 + } 666 666 + l.Warn("some patches failed to apply", "failed", failedHashes) 667 667 + d.pages.Notice(w, noticeId, fmt.Sprintf("Some patches failed to apply: %v", failedHashes)) 668 668 + return 669 669 + } 670 670 + 671 671 + l.Info("patches applied successfully", "count", len(applyResult.Applied)) 672 672 + 673 673 + // Publish sh.tangled.pijul.refUpdate to committer's PDS. 674 674 + // The appview has the user's active OAuth session here — publish directly 675 675 + // instead of routing through the event queue. 676 676 + // Non-fatal: log and continue if PDS write fails. 677 677 + go d.publishPijulRefUpdate(r.Context(), r, repo, discussion.TargetChannel, applyResult.Applied, applyResult.NewState, user.Did()) 678 678 + 679 679 + // Mark discussion as merged 680 680 + if err := db.MergeDiscussion(d.db, discussion.RepoAt, discussion.DiscussionId); err != nil { 681 681 + l.Error("failed to merge discussion", "err", err) 682 682 + d.pages.Notice(w, noticeId, "Failed to merge discussion") 683 683 + return 684 684 + } 685 685 + 686 686 + l.Info("discussion merged", "discussion_id", discussion.DiscussionId) 687 687 + 688 688 + repo, _ = d.repoResolver.Resolve(r) 689 689 + d.pages.HxLocation(w, fmt.Sprintf("/%s/%s/discussions/%d", 690 690 + repo.Did, repo.Name, discussion.DiscussionId)) 691 691 + } 692 692 + 693 693 + // publishPijulRefUpdate publishes a sh.tangled.pijul.refUpdate record to the 694 694 + // committer's PDS. The appview has an active OAuth session at merge time, so we 695 695 + // publish directly without routing through the event queue. 696 696 + func (d *Discussions) publishPijulRefUpdate(ctx context.Context, r *http.Request, repo *models.Repo, channel string, appliedHashes []string, newState string, committerDid string) { 697 697 + l := d.logger.With("fn", "publishPijulRefUpdate", "committer", committerDid) 698 698 + 699 699 + atpClient, err := d.oauth.AuthorizedClient(r) 700 700 + if err != nil { 701 701 + l.Warn("no AT session, skipping PDS publish", "err", err) 702 702 + return 703 703 + } 704 704 + 705 705 + repoAt := fmt.Sprintf("at://%s/%s/%s", repo.Did, tangled.RepoNSID, repo.Name) 706 706 + record := &tangled.PijulRefUpdate{ 707 707 + Repo: repoAt, 708 708 + Channel: channel, 709 709 + Changes: appliedHashes, 710 710 + CommitterDid: committerDid, 711 711 + NewState: newState, 712 712 + } 713 713 + 714 714 + rkey := tid.TID() 715 715 + _, err = comatproto.RepoCreateRecord(ctx, atpClient, &comatproto.RepoCreateRecord_Input{ 716 716 + Collection: tangled.PijulRefUpdateNSID, 717 717 + Repo: committerDid, 718 718 + Rkey: &rkey, 719 719 + Record: &lexutil.LexiconTypeDecoder{Val: record}, 720 720 + }) 721 721 + if err != nil { 722 722 + l.Warn("failed to publish pijulRefUpdate to PDS", "err", err) 723 723 + return 724 724 + } 725 725 + 726 726 + l.Info("published pijulRefUpdate to PDS", "repo", repoAt, "changes", len(appliedHashes)) 727 727 + } 728 728 + 729 729 + // knotXrpcc builds an XRPC client that points directly at the given knot. 730 730 + func (d *Discussions) knotXrpcc(knot string) *xrpc.Client { 731 731 + scheme := "http" 732 732 + if !d.config.Core.Dev { 733 733 + scheme = "https" 734 734 + } 735 735 + return &xrpc.Client{Host: fmt.Sprintf("%s://%s", scheme, knot)} 736 736 + } 737 737 + 738 738 + // getChangeFromKnot fetches change details (including dependencies) from knotserver 739 739 + func (d *Discussions) getChangeFromKnot(ctx context.Context, knot, repo, hash string) (*tangled.RepoChangeGet_Output, error) { 740 740 + return tangled.RepoChangeGet(ctx, d.knotXrpcc(knot), hash, repo) 741 741 + } 742 742 + 743 743 + // canAddPatchWithChange checks if a patch can be added to the discussion 744 744 + // Uses the already-fetched change object to avoid duplicate API calls 745 745 + // Returns error if the patch depends on a removed patch 746 746 + func (d *Discussions) canAddPatchWithChange(discussion *models.Discussion, change *tangled.RepoChangeGet_Output) error { 747 747 + 748 748 + if len(change.Dependencies) == 0 { 749 749 + return nil // No dependencies, can always add 750 750 + } 751 751 + 752 752 + // Get all patches in this discussion 753 753 + patches, err := db.GetDiscussionPatches(d.db, orm.FilterEq("discussion_at", discussion.AtUri())) 754 754 + if err != nil { 755 755 + return fmt.Errorf("failed to get discussion patches: %w", err) 756 756 + } 757 757 + 758 758 + // Check if any dependency is a removed patch in this discussion 759 759 + for _, dep := range change.Dependencies { 760 760 + for _, patch := range patches { 761 761 + if patch.PatchHash == dep && !patch.IsActive() { 762 762 + return fmt.Errorf("cannot add patch: it depends on removed patch %s", dep[:12]) 763 763 + } 764 764 + } 765 765 + } 766 766 + 767 767 + return nil 768 768 + } 769 769 + 770 770 + // canRemovePatch checks if a patch can be removed from the discussion 771 771 + // Returns error if other active patches depend on this patch 772 772 + func (d *Discussions) canRemovePatch(ctx context.Context, discussion *models.Discussion, knot, repo, patchHashToRemove string) error { 773 773 + // Get all active patches in this discussion 774 774 + patches, err := db.GetDiscussionPatches(d.db, orm.FilterEq("discussion_at", discussion.AtUri())) 775 775 + if err != nil { 776 776 + return fmt.Errorf("failed to get discussion patches: %w", err) 777 777 + } 778 778 + 779 779 + // For each active patch, check if it depends on the patch we want to remove 780 780 + for _, patch := range patches { 781 781 + if !patch.IsActive() || patch.PatchHash == patchHashToRemove { 782 782 + continue 783 783 + } 784 784 + 785 785 + // Get the change details to check its dependencies 786 786 + change, err := d.getChangeFromKnot(ctx, knot, repo, patch.PatchHash) 787 787 + if err != nil { 788 788 + d.logger.Warn("failed to get change dependencies", "hash", patch.PatchHash, "err", err) 789 789 + continue // Skip if we can't get the change, but don't block removal 790 790 + } 791 791 + 792 792 + for _, dep := range change.Dependencies { 793 793 + if dep == patchHashToRemove { 794 794 + return fmt.Errorf("cannot remove patch: patch %s depends on it", patch.PatchHash[:12]) 795 795 + } 796 796 + } 797 797 + } 798 798 + 799 799 + return nil 800 800 + }

+53

appview/discussions/router.go

reviewed

··· 1 1 + package discussions 2 2 + 3 3 + import ( 4 4 + "net/http" 5 5 + 6 6 + "github.com/go-chi/chi/v5" 7 7 + "tangled.org/core/appview/middleware" 8 8 + ) 9 9 + 10 10 + func (d *Discussions) Router(mw *middleware.Middleware) http.Handler { 11 11 + r := chi.NewRouter() 12 12 + 13 13 + r.Route("/", func(r chi.Router) { 14 14 + r.With(middleware.Paginate).Get("/", d.RepoDiscussionsList) 15 15 + 16 16 + // Authenticated routes for creating discussions 17 17 + r.Group(func(r chi.Router) { 18 18 + r.Use(middleware.AuthMiddleware(d.oauth)) 19 19 + r.Get("/new", d.NewDiscussion) 20 20 + r.Post("/new", d.NewDiscussion) 21 21 + }) 22 22 + 23 23 + // Single discussion routes 24 24 + r.Route("/{discussion}", func(r chi.Router) { 25 25 + r.Use(mw.ResolveDiscussion) 26 26 + r.Get("/", d.RepoSingleDiscussion) 27 27 + 28 28 + // Authenticated routes 29 29 + r.Group(func(r chi.Router) { 30 30 + r.Use(middleware.AuthMiddleware(d.oauth)) 31 31 + 32 32 + // Comments 33 33 + r.Post("/comment", d.NewComment) 34 34 + 35 35 + // Patches - anyone authenticated can add patches 36 36 + r.Post("/patches", d.AddPatch) 37 37 + 38 38 + // Patch management 39 39 + r.Route("/patches/{patchId}", func(r chi.Router) { 40 40 + r.Delete("/", d.RemovePatch) 41 41 + r.Post("/readd", d.ReaddPatch) 42 42 + }) 43 43 + 44 44 + // Discussion state changes 45 45 + r.Post("/close", d.CloseDiscussion) 46 46 + r.Post("/reopen", d.ReopenDiscussion) 47 47 + r.Post("/merge", d.MergeDiscussion) 48 48 + }) 49 49 + }) 50 50 + }) 51 51 + 52 52 + return r 53 53 + }

+39

appview/ingester.go

reviewed

··· 87 87 err = i.ingestLabelDefinition(e) 88 88 case tangled.LabelOpNSID: 89 89 err = i.ingestLabelOp(e) 90 90 + case tangled.PijulRefUpdateNSID: 91 91 + err = i.ingestPijulRefUpdate(e) 90 92 } 91 93 l = i.Logger.With("nsid", e.Commit.Collection) 92 94 } ··· 1131 1133 1132 1134 return nil 1133 1135 } 1136 1136 + 1137 1137 + // ingestPijulRefUpdate handles sh.tangled.pijul.refUpdate records published to 1138 1138 + // the committer's PDS after a pijul push or merge. It updates the contributor 1139 1139 + // punchcard using the number of changes pushed. 1140 1140 + func (i *Ingester) ingestPijulRefUpdate(e *jmodels.Event) error { 1141 1141 + if e.Commit.Operation != jmodels.CommitOperationCreate { 1142 1142 + return nil 1143 1143 + } 1144 1144 + 1145 1145 + committerDid := e.Did 1146 1146 + 1147 1147 + var record tangled.PijulRefUpdate 1148 1148 + if err := json.Unmarshal(e.Commit.Record, &record); err != nil { 1149 1149 + return fmt.Errorf("invalid pijulRefUpdate record: %w", err) 1150 1150 + } 1151 1151 + 1152 1152 + if record.Repo == "" || len(record.Changes) == 0 { 1153 1153 + return nil 1154 1154 + } 1155 1155 + 1156 1156 + repoAt, err := syntax.ParseATURI(record.Repo) 1157 1157 + if err != nil { 1158 1158 + return fmt.Errorf("invalid repo AT URI %q: %w", record.Repo, err) 1159 1159 + } 1160 1160 + 1161 1161 + if _, err := db.GetRepoByAtUri(i.Db, repoAt.String()); err != nil { 1162 1162 + // Unknown repo — ignore rather than error; the repo may not be 1163 1163 + // registered on this appview instance. 1164 1164 + return nil 1165 1165 + } 1166 1166 + 1167 1167 + return db.AddPunch(i.Db, models.Punch{ 1168 1168 + Did: committerDid, 1169 1169 + Date: time.Now(), 1170 1170 + Count: len(record.Changes), 1171 1171 + }) 1172 1172 + }

+31

appview/middleware/middleware.go

reviewed

··· 321 321 }) 322 322 } 323 323 324 324 + // middleware that is tacked on top of /{user}/{repo}/discussions/{discussion} 325 325 + func (mw Middleware) ResolveDiscussion(next http.Handler) http.Handler { 326 326 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 327 327 + f, err := mw.repoResolver.Resolve(r) 328 328 + if err != nil { 329 329 + log.Println("failed to fully resolve repo", err) 330 330 + w.WriteHeader(http.StatusNotFound) 331 331 + mw.pages.ErrorKnot404(w) 332 332 + return 333 333 + } 334 334 + 335 335 + discussionIdStr := chi.URLParam(r, "discussion") 336 336 + discussionId, err := strconv.Atoi(discussionIdStr) 337 337 + if err != nil { 338 338 + log.Println("failed to fully resolve discussion ID", err) 339 339 + mw.pages.Error404(w) 340 340 + return 341 341 + } 342 342 + 343 343 + discussion, err := db.GetDiscussion(mw.db, f.RepoAt(), discussionId) 344 344 + if err != nil { 345 345 + log.Println("failed to get discussion", "err", err) 346 346 + mw.pages.Error404(w) 347 347 + return 348 348 + } 349 349 + 350 350 + ctx := context.WithValue(r.Context(), "discussion", discussion) 351 351 + next.ServeHTTP(w, r.WithContext(ctx)) 352 352 + }) 353 353 + } 354 354 + 324 355 // this should serve the go-import meta tag even if the path is technically 325 356 // a 404 like tangled.sh/oppi.li/go-git/v5 326 357 //

+243

appview/models/discussion.go

reviewed

··· 1 1 + package models 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "sort" 6 6 + "time" 7 7 + 8 8 + "github.com/bluesky-social/indigo/atproto/syntax" 9 9 + ) 10 10 + 11 11 + // DiscussionState represents the state of a discussion 12 12 + type DiscussionState int 13 13 + 14 14 + const ( 15 15 + DiscussionClosed DiscussionState = iota 16 16 + DiscussionOpen 17 17 + DiscussionMerged 18 18 + ) 19 19 + 20 20 + func (s DiscussionState) String() string { 21 21 + switch s { 22 22 + case DiscussionOpen: 23 23 + return "open" 24 24 + case DiscussionMerged: 25 25 + return "merged" 26 26 + case DiscussionClosed: 27 27 + return "closed" 28 28 + default: 29 29 + return "closed" 30 30 + } 31 31 + } 32 32 + 33 33 + func (s DiscussionState) IsOpen() bool { return s == DiscussionOpen } 34 34 + func (s DiscussionState) IsMerged() bool { return s == DiscussionMerged } 35 35 + func (s DiscussionState) IsClosed() bool { return s == DiscussionClosed } 36 36 + 37 37 + // Discussion represents a discussion in a Pijul repository 38 38 + // Anyone can add patches to a discussion 39 39 + type Discussion struct { 40 40 + // ids 41 41 + Id int64 42 42 + Did string 43 43 + Rkey string 44 44 + RepoAt syntax.ATURI 45 45 + DiscussionId int 46 46 + 47 47 + // content 48 48 + Title string 49 49 + Body string 50 50 + TargetChannel string 51 51 + State DiscussionState 52 52 + 53 53 + // meta 54 54 + Created time.Time 55 55 + Edited *time.Time 56 56 + 57 57 + // populated on query 58 58 + Patches []*DiscussionPatch 59 59 + Comments []DiscussionComment 60 60 + Labels LabelState 61 61 + Repo *Repo 62 62 + } 63 63 + 64 64 + const DiscussionNSID = "sh.tangled.repo.discussion" 65 65 + 66 66 + func (d *Discussion) AtUri() syntax.ATURI { 67 67 + return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", d.Did, DiscussionNSID, d.Rkey)) 68 68 + } 69 69 + 70 70 + // ActivePatches returns only the patches that haven't been removed 71 71 + func (d *Discussion) ActivePatches() []*DiscussionPatch { 72 72 + var active []*DiscussionPatch 73 73 + for _, p := range d.Patches { 74 74 + if p.IsActive() { 75 75 + active = append(active, p) 76 76 + } 77 77 + } 78 78 + return active 79 79 + } 80 80 + 81 81 + // Participants returns all DIDs that have participated in this discussion 82 82 + // (creator + patch pushers + commenters) 83 83 + func (d *Discussion) Participants() []string { 84 84 + participantSet := make(map[string]struct{}) 85 85 + participants := []string{} 86 86 + 87 87 + addParticipant := func(did string) { 88 88 + if _, exists := participantSet[did]; !exists { 89 89 + participantSet[did] = struct{}{} 90 90 + participants = append(participants, did) 91 91 + } 92 92 + } 93 93 + 94 94 + // Discussion creator 95 95 + addParticipant(d.Did) 96 96 + 97 97 + // Patch pushers 98 98 + for _, p := range d.Patches { 99 99 + addParticipant(p.PushedByDid) 100 100 + } 101 101 + 102 102 + // Commenters 103 103 + for _, c := range d.Comments { 104 104 + addParticipant(c.Did) 105 105 + } 106 106 + 107 107 + return participants 108 108 + } 109 109 + 110 110 + // CommentList returns a threaded comment list 111 111 + func (d *Discussion) CommentList() []DiscussionCommentListItem { 112 112 + toplevel := make(map[string]*DiscussionCommentListItem) 113 113 + var replies []*DiscussionComment 114 114 + 115 115 + for i := range d.Comments { 116 116 + comment := &d.Comments[i] 117 117 + if comment.IsTopLevel() { 118 118 + toplevel[comment.AtUri().String()] = &DiscussionCommentListItem{ 119 119 + Self: comment, 120 120 + } 121 121 + } else { 122 122 + replies = append(replies, comment) 123 123 + } 124 124 + } 125 125 + 126 126 + for _, r := range replies { 127 127 + parentAt := *r.ReplyTo 128 128 + if parent, exists := toplevel[parentAt]; exists { 129 129 + parent.Replies = append(parent.Replies, r) 130 130 + } 131 131 + } 132 132 + 133 133 + var listing []DiscussionCommentListItem 134 134 + for _, v := range toplevel { 135 135 + listing = append(listing, *v) 136 136 + } 137 137 + 138 138 + // Sort by creation time 139 139 + sortFunc := func(a, b *DiscussionComment) bool { 140 140 + return a.Created.Before(b.Created) 141 141 + } 142 142 + sort.Slice(listing, func(i, j int) bool { 143 143 + return sortFunc(listing[i].Self, listing[j].Self) 144 144 + }) 145 145 + for _, r := range listing { 146 146 + sort.Slice(r.Replies, func(i, j int) bool { 147 147 + return sortFunc(r.Replies[i], r.Replies[j]) 148 148 + }) 149 149 + } 150 150 + 151 151 + return listing 152 152 + } 153 153 + 154 154 + // TotalComments returns the total number of comments 155 155 + func (d *Discussion) TotalComments() int { 156 156 + return len(d.Comments) 157 157 + } 158 158 + 159 159 + // DiscussionPatch represents a patch added to a discussion 160 160 + // Key difference from PullSubmission: it has pushed_by_did 161 161 + type DiscussionPatch struct { 162 162 + Id int64 163 163 + DiscussionAt syntax.ATURI 164 164 + PushedByDid string 165 165 + PatchHash string 166 166 + Patch string 167 167 + Added time.Time 168 168 + Removed *time.Time 169 169 + } 170 170 + 171 171 + // IsActive returns true if the patch hasn't been removed 172 172 + func (p *DiscussionPatch) IsActive() bool { 173 173 + return p.Removed == nil 174 174 + } 175 175 + 176 176 + // CanRemove checks if the given user can remove this patch 177 177 + // A patch can be removed by: 178 178 + // 1. The person who pushed it 179 179 + // 2. Someone with edit permissions on the repo 180 180 + func (p *DiscussionPatch) CanRemove(userDid string, hasEditPerm bool) bool { 181 181 + return p.PushedByDid == userDid || hasEditPerm 182 182 + } 183 183 + 184 184 + // DiscussionComment represents a comment on a discussion 185 185 + type DiscussionComment struct { 186 186 + Id int64 187 187 + Did string 188 188 + Rkey string 189 189 + DiscussionAt string 190 190 + ReplyTo *string 191 191 + Body string 192 192 + Created time.Time 193 193 + Edited *time.Time 194 194 + Deleted *time.Time 195 195 + } 196 196 + 197 197 + const DiscussionCommentNSID = "sh.tangled.repo.discussion.comment" 198 198 + 199 199 + func (c *DiscussionComment) AtUri() syntax.ATURI { 200 200 + return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", c.Did, DiscussionCommentNSID, c.Rkey)) 201 201 + } 202 202 + 203 203 + func (c *DiscussionComment) IsTopLevel() bool { 204 204 + return c.ReplyTo == nil 205 205 + } 206 206 + 207 207 + func (c *DiscussionComment) IsReply() bool { 208 208 + return c.ReplyTo != nil 209 209 + } 210 210 + 211 211 + // DiscussionCommentListItem represents a top-level comment with its replies 212 212 + type DiscussionCommentListItem struct { 213 213 + Self *DiscussionComment 214 214 + Replies []*DiscussionComment 215 215 + } 216 216 + 217 217 + // Participants returns all DIDs that participated in this comment thread 218 218 + func (item *DiscussionCommentListItem) Participants() []syntax.DID { 219 219 + participantSet := make(map[syntax.DID]struct{}) 220 220 + participants := []syntax.DID{} 221 221 + 222 222 + addParticipant := func(did syntax.DID) { 223 223 + if _, exists := participantSet[did]; !exists { 224 224 + participantSet[did] = struct{}{} 225 225 + participants = append(participants, did) 226 226 + } 227 227 + } 228 228 + 229 229 + addParticipant(syntax.DID(item.Self.Did)) 230 230 + 231 231 + for _, c := range item.Replies { 232 232 + addParticipant(syntax.DID(c.Did)) 233 233 + } 234 234 + 235 235 + return participants 236 236 + } 237 237 + 238 238 + // DiscussionCount holds counts for different discussion states 239 239 + type DiscussionCount struct { 240 240 + Open int 241 241 + Merged int 242 242 + Closed int 243 243 + }

+14 -4

appview/models/repo.go

reviewed

··· 23 23 Spindle string 24 24 Labels []string 25 25 RepoDid string 26 26 + Vcs string // "git" or "pijul" 26 27 27 28 // optionally, populate this when querying for reverse mappings 28 29 RepoStats *RepoStats 29 30 30 31 // optional 31 32 Source string 33 33 + } 34 34 + 35 35 + func (r *Repo) IsGit() bool { 36 36 + return r.Vcs == "" || r.Vcs == "git" 37 37 + } 38 38 + 39 39 + func (r *Repo) IsPijul() bool { 40 40 + return r.Vcs == "pijul" 32 41 } 33 42 34 43 func (r *Repo) AsRecord() tangled.Repo { ··· 93 102 } 94 103 95 104 type RepoStats struct { 96 96 - Language string 97 97 - StarCount int 98 98 - IssueCount IssueCount 99 99 - PullCount PullCount 105 105 + Language string 106 106 + StarCount int 107 107 + IssueCount IssueCount 108 108 + PullCount PullCount 109 109 + DiscussionCount DiscussionCount 100 110 } 101 111 102 112 type IssueCount struct {

+5 -1

appview/oauth/oauth.go

reviewed

··· 7 7 "log/slog" 8 8 "net/http" 9 9 "net/url" 10 10 + "strings" 10 11 "sync" 11 12 "time" 12 13 ··· 270 271 return session.APIClient(), nil 271 272 } 272 273 274 274 + 273 275 // this is a higher level abstraction on ServerGetServiceAuth 274 276 type ServiceClientOpts struct { 275 277 service string ··· 321 323 } 322 324 323 325 func (s *ServiceClientOpts) Audience() string { 324 324 - return fmt.Sprintf("did:web:%s", s.service) 326 326 + // did:web spec requires colons to be encoded as %3A 327 327 + encoded := strings.ReplaceAll(s.service, ":", "%3A") 328 328 + return fmt.Sprintf("did:web:%s", encoded) 325 329 } 326 330 327 331 func (s *ServiceClientOpts) Host() string {

+2

appview/oauth/scopes.go

reviewed

··· 38 38 "rpc:sh.tangled.repo.addSecret?aud=*", 39 39 "rpc:sh.tangled.repo.removeSecret?aud=*", 40 40 "rpc:sh.tangled.repo.listSecrets?aud=*", 41 41 + "rpc:sh.tangled.repo.applyChanges?aud=*", 42 42 + "rpc:sh.tangled.repo.unrecordChanges?aud=*", 41 43 }

+1

appview/oauth/store.go

reviewed

··· 88 88 return fmt.Sprintf("oauth:auth_request:%s", state) 89 89 } 90 90 91 91 + 91 92 func (r *RedisStore) GetSession(ctx context.Context, did syntax.DID, sessionID string) (*oauth.ClientSessionData, error) { 92 93 key := sessionKey(did, sessionID) 93 94 metaKey := sessionMetadataKey(did, sessionID)

+99

appview/pages/pages.go

reviewed

··· 837 837 return p.executeRepo("repo/log", w, params) 838 838 } 839 839 840 840 + type PijulChangeView struct { 841 841 + Hash string 842 842 + Authors []*tangled.RepoChangeList_Author 843 843 + Message string 844 844 + Dependencies []string 845 845 + Timestamp time.Time 846 846 + HasTimestamp bool 847 847 + } 848 848 + 849 849 + type RepoChangesParams struct { 850 850 + LoggedInUser *oauth.MultiAccountUser 851 851 + RepoInfo repoinfo.RepoInfo 852 852 + Active string 853 853 + Page int 854 854 + Changes []PijulChangeView 855 855 + } 856 856 + 857 857 + func (p *Pages) RepoChanges(w io.Writer, params RepoChangesParams) error { 858 858 + params.Active = "changes" 859 859 + return p.executeRepo("repo/changes", w, params) 860 860 + } 861 861 + 862 862 + type RepoChangeParams struct { 863 863 + LoggedInUser *oauth.MultiAccountUser 864 864 + RepoInfo repoinfo.RepoInfo 865 865 + Active string 866 866 + Change PijulChangeDetail 867 867 + } 868 868 + 869 869 + func (p *Pages) RepoChange(w io.Writer, params RepoChangeParams) error { 870 870 + params.Active = "changes" 871 871 + return p.executeRepo("repo/change", w, params) 872 872 + } 873 873 + 874 874 + type PijulChangeDetail struct { 875 875 + Hash string 876 876 + Authors []*tangled.RepoChangeGet_Author 877 877 + Message string 878 878 + Dependencies []string 879 879 + Diff string 880 880 + HasDiff bool 881 881 + DiffLines []PijulDiffLine 882 882 + Timestamp time.Time 883 883 + HasTimestamp bool 884 884 + } 885 885 + 886 886 + type PijulDiffLine struct { 887 887 + Kind string 888 888 + Op string 889 889 + Body string 890 890 + Text string 891 891 + OldLine int64 892 892 + NewLine int64 893 893 + HasOld bool 894 894 + HasNew bool 895 895 + } 896 896 + 840 897 type RepoCommitParams struct { 841 898 LoggedInUser *oauth.MultiAccountUser 842 899 RepoInfo repoinfo.RepoInfo ··· 1666 1723 func (p *Pages) Error503(w io.Writer) error { 1667 1724 return p.execute("errors/503", w, nil) 1668 1725 } 1726 1726 + 1727 1727 + // Pijul Discussion pages - these are different from Git's issues/PRs 1728 1728 + 1729 1729 + type RepoDiscussionsListParams struct { 1730 1730 + LoggedInUser *oauth.MultiAccountUser 1731 1731 + RepoInfo repoinfo.RepoInfo 1732 1732 + Active string 1733 1733 + Discussions []models.Discussion 1734 1734 + Filter string 1735 1735 + DiscussionCount models.DiscussionCount 1736 1736 + } 1737 1737 + 1738 1738 + func (p *Pages) RepoDiscussionsList(w io.Writer, params RepoDiscussionsListParams) error { 1739 1739 + params.Active = "discussions" 1740 1740 + return p.executeRepo("repo/pijul/discussions/list", w, params) 1741 1741 + } 1742 1742 + 1743 1743 + type NewDiscussionParams struct { 1744 1744 + LoggedInUser *oauth.MultiAccountUser 1745 1745 + RepoInfo repoinfo.RepoInfo 1746 1746 + Active string 1747 1747 + } 1748 1748 + 1749 1749 + func (p *Pages) NewDiscussion(w io.Writer, params NewDiscussionParams) error { 1750 1750 + params.Active = "discussions" 1751 1751 + return p.executeRepo("repo/pijul/discussions/new", w, params) 1752 1752 + } 1753 1753 + 1754 1754 + type RepoSingleDiscussionParams struct { 1755 1755 + LoggedInUser *oauth.MultiAccountUser 1756 1756 + RepoInfo repoinfo.RepoInfo 1757 1757 + Active string 1758 1758 + Discussion *models.Discussion 1759 1759 + CommentList []models.DiscussionCommentListItem 1760 1760 + CanManage bool 1761 1761 + ActivePatches []*models.DiscussionPatch 1762 1762 + } 1763 1763 + 1764 1764 + func (p *Pages) RepoSingleDiscussion(w io.Writer, params RepoSingleDiscussionParams) error { 1765 1765 + params.Active = "discussions" 1766 1766 + return p.executeRepo("repo/pijul/discussions/single", w, params) 1767 1767 + }

+34 -7

appview/pages/repoinfo/repoinfo.go

reviewed

··· 38 38 func (r RepoInfo) GetTabs() [][]string { 39 39 tabs := [][]string{ 40 40 {"overview", "/", "square-chart-gantt"}, 41 41 - {"issues", "/issues", "circle-dot"}, 42 42 - {"pulls", "/pulls", "git-pull-request"}, 43 43 - {"pipelines", "/pipelines", "layers-2"}, 41 41 + } 42 42 + 43 43 + if r.IsPijul() { 44 44 + tabs = append(tabs, []string{"changes", "/changes", "logs"}) 45 45 + tabs = append(tabs, []string{"discussions", "/discussions", "message-square"}) 46 46 + } else { 47 47 + tabs = append(tabs, []string{"issues", "/issues", "circle-dot"}) 48 48 + tabs = append(tabs, []string{"pulls", "/pulls", "git-pull-request"}) 44 49 } 45 50 51 51 + tabs = append(tabs, []string{"pipelines", "/pipelines", "layers-2"}) 52 52 + 46 53 if r.Roles.SettingsAllowed() { 47 54 tabs = append(tabs, []string{"settings", "/settings", "cog"}) 48 55 } ··· 64 71 Topics []string 65 72 Knot string 66 73 Spindle string 74 74 + Vcs string // "git" or "pijul" 67 75 IsStarred bool 68 76 Stats models.RepoStats 69 77 Roles RolesInRepo ··· 72 80 CurrentDir string 73 81 } 74 82 83 83 + func (r RepoInfo) IsGit() bool { 84 84 + return r.Vcs == "" || r.Vcs == "git" 85 85 + } 86 86 + 87 87 + func (r RepoInfo) IsPijul() bool { 88 88 + return r.Vcs == "pijul" 89 89 + } 90 90 + 75 91 // each tab on a repo could have some metadata: 76 92 // 77 93 // issues -> number of open issues etc. ··· 82 98 func (r RepoInfo) TabMetadata() map[string]any { 83 99 meta := make(map[string]any) 84 100 85 85 - meta["pulls"] = r.Stats.PullCount.Open 86 86 - meta["issues"] = r.Stats.IssueCount.Open 87 87 - 88 88 - // more stuff? 101 101 + if r.IsPijul() { 102 102 + // Pijul repos use discussions 103 103 + meta["discussions"] = r.Stats.DiscussionCount.Open 104 104 + } else { 105 105 + // Git repos use separate issues and pulls 106 106 + meta["issues"] = r.Stats.IssueCount.Open 107 107 + meta["pulls"] = r.Stats.PullCount.Open 108 108 + } 89 109 90 110 return meta 91 111 } ··· 117 137 func (r RolesInRepo) IsPushAllowed() bool { 118 138 return slices.Contains(r.Roles, "repo:push") 119 139 } 140 140 + 141 141 + // CanManageRepo returns true if the user has any role that grants management 142 142 + // access (owner, collaborator, or push). Used for actions like closing/merging 143 143 + // discussions, removing patches, etc. 144 144 + func (r RolesInRepo) CanManageRepo() bool { 145 145 + return r.IsOwner() || r.IsCollaborator() || r.IsPushAllowed() 146 146 + }

+110

appview/pages/templates/repo/change.html

reviewed

··· 1 1 + {{ define "title" }} change {{ .Change.Hash }} &middot; {{ .RepoInfo.FullName }} {{ end }} 2 2 + 3 3 + {{ define "repoContent" }} 4 4 + {{ $repo := .RepoInfo.FullName }} 5 5 + {{ $change := .Change }} 6 6 + 7 7 + <section class="dark:text-white"> 8 8 + <h1 class="mt-2">{{ $change.Message }}</h1> 9 9 + 10 10 + <div class="flex items-center gap-3 py-3"> 11 11 + {{ if $change.Authors }} 12 12 + {{ $author := index $change.Authors 0 }} 13 13 + {{ if $author.Did }} 14 14 + <a href="/{{ resolve (deref $author.Did) }}"> 15 15 + {{ template "user/fragments/pic" (list (deref $author.Did) "h-10 w-10") }} 16 16 + </a> 17 17 + {{ else }} 18 18 + {{ placeholderAvatar "md" }} 19 19 + {{ end }} 20 20 + <div class="flex flex-col"> 21 21 + <div> 22 22 + {{ range $idx, $a := $change.Authors }} 23 23 + {{ if gt $idx 0 }}, {{ end }} 24 24 + {{ if $a.Did }} 25 25 + <a href="/{{ resolve (deref $a.Did) }}" class="no-underline hover:underline text-gray-700 dark:text-gray-300">{{ deref $a.Did | resolve | truncateAt30 }}</a> 26 26 + {{ else }} 27 27 + {{ $a.Name }}{{ if $a.Email }} &lt;{{ $a.Email }}&gt;{{ end }} 28 28 + {{ end }} 29 29 + {{ end }} 30 30 + </div> 31 31 + {{ if $change.HasTimestamp }} 32 32 + <div class="text-sm text-gray-500 dark:text-gray-400"> 33 33 + {{ template "repo/fragments/time" $change.Timestamp }} 34 34 + </div> 35 35 + {{ end }} 36 36 + <div class="font-mono text-sm text-gray-500 dark:text-gray-400 break-all">{{ $change.Hash }}</div> 37 37 + </div> 38 38 + {{ else }} 39 39 + {{ placeholderAvatar "md" }} 40 40 + <div class="text-gray-500">unknown</div> 41 41 + {{ end }} 42 42 + </div> 43 43 + 44 44 + {{ if .RepoInfo.Roles.CanManageRepo }} 45 45 + <div class="mt-4" id="change"> 46 46 + <button 47 47 + class="px-3 py-1.5 text-sm font-medium text-red-600 dark:text-red-400 border border-red-300 dark:border-red-700 rounded hover:bg-red-50 dark:hover:bg-red-900/30 cursor-pointer" 48 48 + hx-post="/{{ $repo }}/change/{{ $change.Hash }}/unrecord" 49 49 + hx-confirm="Are you sure you want to unrecord this change? This will remove it from the current channel." 50 50 + hx-swap="none" 51 51 + > 52 52 + Unrecord 53 53 + </button> 54 54 + </div> 55 55 + {{ end }} 56 56 + 57 57 + <h2 class="mt-6 text-sm uppercase text-gray-600 dark:text-gray-400">Dependencies</h2> 58 58 + <ul class="mt-2"> 59 59 + {{ if $change.Dependencies }} 60 60 + {{ range $change.Dependencies }} 61 61 + <li class="font-mono text-sm break-all"> 62 62 + <a class="no-underline hover:underline" href="/{{ $repo }}/change/{{ . }}">{{ . }}</a> 63 63 + </li> 64 64 + {{ end }} 65 65 + {{ else }} 66 66 + <li class="text-sm text-gray-500">none</li> 67 67 + {{ end }} 68 68 + </ul> 69 69 + 70 70 + <h2 class="mt-8 text-sm uppercase text-gray-600 dark:text-gray-400">Change contents</h2> 71 71 + {{ if $change.HasDiff }} 72 72 + {{ if $change.DiffLines }} 73 73 + <div class="overflow-x-auto text-sm bg-gray-50 dark:bg-gray-900 p-3 rounded mt-2 font-mono"> 74 74 + {{ $lineNrStyle := "min-w-[3.5rem] flex-shrink-0 select-none text-right bg-white dark:bg-gray-800" }} 75 75 + {{ $lineNrSepStyle1 := "" }} 76 76 + {{ $lineNrSepStyle2 := "pr-2 border-r border-gray-200 dark:border-gray-700" }} 77 77 + {{ $containerStyle := "inline-flex w-full items-center" }} 78 78 + {{ range $change.DiffLines }} 79 79 + {{ if eq .Kind "section" }} 80 80 + <div class="whitespace-pre text-xs uppercase tracking-wide text-gray-600 dark:text-gray-300 mt-3">{{ .Text }}</div> 81 81 + {{ else if eq .Kind "meta" }} 82 82 + <div class="whitespace-pre text-gray-500 dark:text-gray-400">{{ .Text }}</div> 83 83 + {{ else }} 84 84 + {{ $lineClass := "bg-white dark:bg-gray-800 text-gray-500 dark:text-gray-400" }} 85 85 + {{ if eq .Kind "add" }} 86 86 + {{ $lineClass = "bg-green-100 dark:bg-green-800/30 text-green-700 dark:text-green-400" }} 87 87 + {{ else if eq .Kind "del" }} 88 88 + {{ $lineClass = "bg-red-100 dark:bg-red-800/30 text-red-700 dark:text-red-400" }} 89 89 + {{ end }} 90 90 + <div class="{{ $containerStyle }} {{ $lineClass }}"> 91 91 + <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle1 }}"> 92 92 + {{ if .HasOld }}{{ .OldLine }}{{ else }}<span aria-hidden="true" class="invisible">0</span>{{ end }} 93 93 + </div> 94 94 + <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle2 }}"> 95 95 + {{ if .HasNew }}{{ .NewLine }}{{ else }}<span aria-hidden="true" class="invisible">0</span>{{ end }} 96 96 + </div> 97 97 + <div class="w-5 flex-shrink-0 select-none text-center">{{ .Op }}</div> 98 98 + <div class="px-2 whitespace-pre">{{ .Body }}</div> 99 99 + </div> 100 100 + {{ end }} 101 101 + {{ end }} 102 102 + </div> 103 103 + {{ else }} 104 104 + <pre class="overflow-x-auto text-sm bg-gray-50 dark:bg-gray-900 p-3 rounded mt-2 font-mono whitespace-pre">{{ $change.Diff }}</pre> 105 105 + {{ end }} 106 106 + {{ else }} 107 107 + <div class="text-sm text-gray-500 mt-2">no diff available</div> 108 108 + {{ end }} 109 109 + </section> 110 110 + {{ end }}

+153

appview/pages/templates/repo/changes.html

reviewed

··· 1 1 + {{ define "title" }}changes &middot; {{ .RepoInfo.FullName }}{{ end }} 2 2 + 3 3 + {{ define "extrameta" }} 4 4 + {{ $title := printf "changes &middot; %s" .RepoInfo.FullName }} 5 5 + {{ $url := printf "https://tangled.org/%s/changes" .RepoInfo.FullName }} 6 6 + 7 7 + {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }} 8 8 + {{ end }} 9 9 + 10 10 + {{ define "repoContent" }} 11 11 + <section id="change-table" class="overflow-x-auto"> 12 12 + <h2 class="font-bold text-sm mb-4 uppercase dark:text-white"> 13 13 + changes 14 14 + </h2> 15 15 + 16 16 + <!-- desktop view (hidden on small screens) --> 17 17 + <div class="hidden md:flex md:flex-col divide-y divide-gray-200 dark:divide-gray-700"> 18 18 + {{ $grid := "grid grid-cols-14 gap-4" }} 19 19 + <div class="{{ $grid }}"> 20 20 + <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-3">Author</div> 21 21 + <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-3">Change</div> 22 22 + <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-6">Message</div> 23 23 + <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-2 justify-self-end">Date</div> 24 24 + </div> 25 25 + {{ range $index, $change := .Changes }} 26 26 + {{ $messageParts := splitN $change.Message "\n\n" 2 }} 27 27 + <div class="{{ $grid }} py-3"> 28 28 + <div class="align-top col-span-3"> 29 29 + {{ template "pijulAttribution" $change }} 30 30 + </div> 31 31 + <div class="align-top font-mono flex items-start col-span-3"> 32 32 + {{ $hashStyle := "text-gray-700 dark:text-gray-300 bg-gray-100 dark:bg-gray-900" }} 33 33 + <a href="/{{ $.RepoInfo.FullName }}/change/{{ $change.Hash }}" class="no-underline hover:underline {{ $hashStyle }} px-2 py-1/2 rounded flex items-center gap-2"> 34 34 + {{ slice $change.Hash 0 12 }} 35 35 + </a> 36 36 + <div class="ml-2 inline-flex"> 37 37 + <button class="p-1 mx-1 hover:bg-gray-100 dark:hover:bg-gray-700 rounded" 38 38 + title="Copy hash" 39 39 + onclick="navigator.clipboard.writeText('{{ $change.Hash }}'); this.innerHTML=`{{ i "copy-check" "w-4 h-4" }}`; setTimeout(() => this.innerHTML=`{{ i "copy" "w-4 h-4" }}`, 1500)"> 40 40 + {{ i "copy" "w-4 h-4" }} 41 41 + </button> 42 42 + </div> 43 43 + </div> 44 44 + <div class="align-top col-span-6"> 45 45 + <div> 46 46 + <a href="/{{ $.RepoInfo.FullName }}/change/{{ $change.Hash }}" class="dark:text-white no-underline hover:underline">{{ index $messageParts 0 }}</a> 47 47 + 48 48 + {{ if gt (len $messageParts) 1 }} 49 49 + <button class="py-1/2 px-1 bg-gray-200 hover:bg-gray-400 dark:bg-gray-700 dark:hover:bg-gray-600 rounded" hx-on:click="this.parentElement.nextElementSibling.classList.toggle('hidden')">{{ i "ellipsis" "w-3 h-3" }}</button> 50 50 + {{ end }} 51 51 + 52 52 + {{ if $change.Dependencies }} 53 53 + <span class="ml-2 text-xs text-gray-500" title="Depends on {{ len $change.Dependencies }} changes"> 54 54 + {{ i "git-branch" "w-3 h-3 inline" }} {{ len $change.Dependencies }} 55 55 + </span> 56 56 + {{ end }} 57 57 + </div> 58 58 + 59 59 + {{ if gt (len $messageParts) 1 }} 60 60 + <p class="hidden mt-1 text-sm text-gray-600 dark:text-gray-400">{{ nl2br (index $messageParts 1) }}</p> 61 61 + {{ end }} 62 62 + </div> 63 63 + <div class="align-top justify-self-end text-gray-500 dark:text-gray-400 col-span-2"> 64 64 + {{ if $change.HasTimestamp }} 65 65 + {{ template "repo/fragments/shortTimeAgo" $change.Timestamp }} 66 66 + {{ end }} 67 67 + </div> 68 68 + </div> 69 69 + {{ end }} 70 70 + </div> 71 71 + 72 72 + <!-- mobile view (visible only on small screens) --> 73 73 + <div class="md:hidden"> 74 74 + {{ range $index, $change := .Changes }} 75 75 + <div class="relative p-2 mb-2 {{ if ne $index (sub (len $.Changes) 1) }}border-b border-gray-200 dark:border-gray-700{{ end }}"> 76 76 + <div id="change-message"> 77 77 + {{ $messageParts := splitN $change.Message "\n\n" 2 }} 78 78 + <div class="text-base cursor-pointer"> 79 79 + <div class="flex items-center justify-between"> 80 80 + <div class="flex-1"> 81 81 + <div> 82 82 + <a href="/{{ $.RepoInfo.FullName }}/change/{{ $change.Hash }}" 83 83 + class="inline no-underline hover:underline dark:text-white"> 84 84 + {{ index $messageParts 0 }} 85 85 + </a> 86 86 + {{ if gt (len $messageParts) 1 }} 87 87 + <button 88 88 + class="py-1/2 px-1 bg-gray-200 hover:bg-gray-400 rounded dark:bg-gray-700 dark:hover:bg-gray-600" 89 89 + hx-on:click="this.parentElement.nextElementSibling.classList.toggle('hidden')"> 90 90 + {{ i "ellipsis" "w-3 h-3" }} 91 91 + </button> 92 92 + {{ end }} 93 93 + </div> 94 94 + 95 95 + {{ if gt (len $messageParts) 1 }} 96 96 + <p class="hidden mt-1 text-sm cursor-text pb-2 dark:text-gray-300"> 97 97 + {{ nl2br (index $messageParts 1) }} 98 98 + </p> 99 99 + {{ end }} 100 100 + </div> 101 101 + </div> 102 102 + </div> 103 103 + </div> 104 104 + 105 105 + <div class="text-xs mt-2 text-gray-500 dark:text-gray-400 flex items-center"> 106 106 + {{ $hashStyle := "text-gray-700 dark:text-gray-300 bg-gray-100 dark:bg-gray-900" }} 107 107 + <span class="font-mono"> 108 108 + <a href="/{{ $.RepoInfo.FullName }}/change/{{ $change.Hash }}" 109 109 + class="no-underline hover:underline {{ $hashStyle }} px-2 py-1 rounded flex items-center gap-2"> 110 110 + {{ slice $change.Hash 0 12 }} 111 111 + </a> 112 112 + </span> 113 113 + <span class="mx-2 before:content-['·'] before:select-none"></span> 114 114 + {{ template "pijulAttribution" $change }} 115 115 + {{ if $change.HasTimestamp }} 116 116 + <div class="inline-block px-1 select-none after:content-['·']"></div> 117 117 + <span>{{ template "repo/fragments/shortTime" $change.Timestamp }}</span> 118 118 + {{ end }} 119 119 + </div> 120 120 + </div> 121 121 + {{ end }} 122 122 + </div> 123 123 + </section> 124 124 + 125 125 + {{ end }} 126 126 + 127 127 + {{ define "pijulAttribution" }} 128 128 + <span class="flex items-center gap-1"> 129 129 + {{ if .Authors }} 130 130 + {{ $author := index .Authors 0 }} 131 131 + {{ if $author.Did }} 132 132 + {{ template "user/fragments/picHandleLink" (deref $author.Did) }} 133 133 + {{ else }} 134 134 + {{ placeholderAvatar "tiny" }} 135 135 + <span class="text-gray-700 dark:text-gray-300"> 136 136 + {{ $author.Name }} 137 137 + </span> 138 138 + {{ end }} 139 139 + {{ if gt (len .Authors) 1 }} <span class="text-gray-500">+{{ sub (len .Authors) 1 }}</span>{{ end }} 140 140 + {{ else }} 141 141 + {{ placeholderAvatar "tiny" }} 142 142 + <span class="text-gray-500">unknown</span> 143 143 + {{ end }} 144 144 + </span> 145 145 + {{ end }} 146 146 + 147 147 + {{ define "repoAfter" }} 148 148 + {{ $changes_len := len .Changes }} 149 149 + <div class="flex justify-end mt-4 gap-2"> 150 150 + {{ if gt .Page 1 }}<a class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700" hx-boost="true" onclick="window.location.href = window.location.pathname + '?page={{ sub .Page 1 }}'">{{ i "chevron-left" "w-4 h-4" }} previous</a>{{ else }}<div></div>{{ end }} 151 151 + {{ if eq $changes_len 60 }}<a class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700" hx-boost="true" onclick="window.location.href = window.location.pathname + '?page={{ add .Page 1 }}'">next {{ i "chevron-right" "w-4 h-4" }}</a>{{ end }} 152 152 + </div> 153 153 + {{ end }}

+91

appview/pages/templates/repo/channels.html

reviewed

··· 1 1 + {{ define "title" }} 2 2 + channels &middot; {{ .RepoInfo.FullName }} 3 3 + {{ end }} 4 4 + 5 5 + {{ define "extrameta" }} 6 6 + {{ $title := printf "channels &middot; %s" .RepoInfo.FullName }} 7 7 + {{ $url := printf "https://tangled.org/%s/channels" .RepoInfo.FullName }} 8 8 + 9 9 + {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }} 10 10 + {{ end }} 11 11 + 12 12 + {{ define "repoContent" }} 13 13 + <section id="channels-table" class="overflow-x-auto"> 14 14 + <h2 class="font-bold text-sm mb-4 uppercase dark:text-white"> 15 15 + Channels 16 16 + </h2> 17 17 + 18 18 + <!-- desktop view (hidden on small screens) --> 19 19 + <table class="w-full border-collapse hidden md:table"> 20 20 + <thead> 21 21 + <tr> 22 22 + <th class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold">Name</th> 23 23 + <th class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold">Status</th> 24 24 + </tr> 25 25 + </thead> 26 26 + <tbody> 27 27 + {{ range $index, $channel := .Channels }} 28 28 + <tr class="{{ if ne $index (sub (len $.Channels) 1) }}border-b border-gray-200 dark:border-gray-700{{ end }}"> 29 29 + <td class="py-3 whitespace-nowrap"> 30 30 + <a href="/{{ $.RepoInfo.FullName }}/tree/{{ .Name | urlquery }}" class="no-underline hover:underline flex items-center gap-2"> 31 31 + <span class="dark:text-white"> 32 32 + {{ .Name }} 33 33 + </span> 34 34 + {{ if .IsCurrent }} 35 35 + <span class=" 36 36 + text-sm rounded 37 37 + bg-gray-100 dark:bg-gray-700 text-black dark:text-white 38 38 + font-mono 39 39 + px-2 mx-1/2 40 40 + inline-flex items-center 41 41 + "> 42 42 + current 43 43 + </span> 44 44 + {{ end }} 45 45 + </a> 46 46 + </td> 47 47 + <td class="py-3 whitespace-nowrap"> 48 48 + {{ if .IsCurrent }} 49 49 + <span class="text-green-600 dark:text-green-400 text-sm">active</span> 50 50 + {{ else }} 51 51 + <span class="text-gray-500 text-sm">-</span> 52 52 + {{ end }} 53 53 + </td> 54 54 + </tr> 55 55 + {{ end }} 56 56 + </tbody> 57 57 + </table> 58 58 + 59 59 + <!-- mobile view (visible only on small screens) --> 60 60 + <div class="md:hidden"> 61 61 + {{ range $index, $channel := .Channels }} 62 62 + <div class="relative p-2 {{ if ne $index (sub (len $.Channels) 1) }}border-b border-gray-200 dark:border-gray-700{{ end }}"> 63 63 + <div class="flex items-center justify-between"> 64 64 + <a href="/{{ $.RepoInfo.FullName }}/tree/{{ .Name | urlquery }}" class="no-underline hover:underline flex items-center gap-2"> 65 65 + <span class="dark:text-white font-medium"> 66 66 + {{ .Name }} 67 67 + </span> 68 68 + {{ if .IsCurrent }} 69 69 + <span class=" 70 70 + text-xs rounded 71 71 + bg-gray-100 dark:bg-gray-700 text-black dark:text-white 72 72 + font-mono 73 73 + px-2 74 74 + inline-flex items-center 75 75 + "> 76 76 + current 77 77 + </span> 78 78 + {{ end }} 79 79 + </a> 80 80 + </div> 81 81 + </div> 82 82 + {{ end }} 83 83 + </div> 84 84 + 85 85 + {{ if not .Channels }} 86 86 + <div class="text-gray-500 dark:text-gray-400 py-4"> 87 87 + No channels found in this repository. 88 88 + </div> 89 89 + {{ end }} 90 90 + </section> 91 91 + {{ end }}

+1 -1

appview/pages/templates/repo/empty.html

reviewed

··· 10 10 {{ if gt (len .BranchesTrunc) 0 }} 11 11 <div class="flex flex-col items-center"> 12 12 <p class="text-center pt-5 text-gray-400 dark:text-gray-500"> 13 13 - This branch is empty. Other branches in this repository are populated: 13 13 + This {{ if .RepoInfo.IsPijul }}channel{{ else }}branch{{ end }} is empty. Other {{ if .RepoInfo.IsPijul }}channels{{ else }}branches{{ end }} in this repository are populated: 14 14 </p> 15 15 <div class="mt-4 grid grid-cols-1 divide-y divide-gray-200 dark:divide-gray-700 rounded border border-gray-200 dark:border-gray-700 w-full md:w-1/2"> 16 16 {{ range $br := .BranchesTrunc }}

+12 -10

appview/pages/templates/repo/fragments/compareForm.html

reviewed

··· 53 53 {{ $name := index . 1 }} 54 54 {{ $default := index . 2 }} 55 55 <select name="{{$name}}" id="{{$name}}-select" class="p-1 border max-w-32 md:max-w-64 border-gray-200 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-700"> 56 56 - <optgroup label="branches ({{ len $root.Branches }})" class="bold text-sm"> 56 56 + <optgroup label="{{ if $root.RepoInfo.IsPijul }}channels{{ else }}branches{{ end }} ({{ len $root.Branches }})" class="bold text-sm"> 57 57 {{ range $root.Branches }} 58 58 <option value="{{ .Reference.Name }}" class="py-1" {{if eq .Reference.Name $default}}selected{{end}}> 59 59 {{ .Reference.Name }} 60 60 </option> 61 61 {{ end }} 62 62 </optgroup> 63 63 - <optgroup label="tags ({{ len $root.Tags }})" class="bold text-sm"> 64 64 - {{ range $root.Tags }} 65 65 - <option value="{{ .Reference.Name }}" class="py-1" {{if eq .Reference.Name $default}}selected{{end}}> 66 66 - {{ .Reference.Name }} 67 67 - </option> 68 68 - {{ else }} 69 69 - <option class="py-1" disabled>no tags found</option> 70 70 - {{ end }} 71 71 - </optgroup> 63 63 + {{ if not $root.RepoInfo.IsPijul }} 64 64 + <optgroup label="tags ({{ len $root.Tags }})" class="bold text-sm"> 65 65 + {{ range $root.Tags }} 66 66 + <option value="{{ .Reference.Name }}" class="py-1" {{if eq .Reference.Name $default}}selected{{end}}> 67 67 + {{ .Reference.Name }} 68 68 + </option> 69 69 + {{ else }} 70 70 + <option class="py-1" disabled>no tags found</option> 71 71 + {{ end }} 72 72 + </optgroup> 73 73 + {{ end }} 72 74 </select> 73 75 {{ end }}

+24 -9

appview/pages/templates/repo/index.html

reviewed

··· 18 18 <a href="/{{ .RepoInfo.FullName }}/commits/{{ .Ref | urlquery }}" class="inline-flex md:hidden items-center text-sm gap-1 font-bold"> 19 19 {{ i "git-commit-horizontal" "w-4" "h-4" }} {{ .TotalCommits }} 20 20 </a> 21 21 - <a href="/{{ .RepoInfo.FullName }}/branches" class="inline-flex md:hidden items-center text-sm gap-1 font-bold"> 21 21 + <a href="/{{ .RepoInfo.FullName }}/{{ if .RepoInfo.IsPijul }}channels{{ else }}branches{{ end }}" class="inline-flex md:hidden items-center text-sm gap-1 font-bold"> 22 22 {{ i "git-branch" "w-4" "h-4" }} {{ len .Branches }} 23 23 </a> 24 24 + {{ if not .RepoInfo.IsPijul }} 24 25 <a href="/{{ .RepoInfo.FullName }}/tags" class="inline-flex md:hidden items-center text-sm gap-1 font-bold"> 25 26 {{ i "tags" "w-4" "h-4" }} {{ len .Tags }} 26 27 </a> 28 28 + {{ end }} 27 29 {{ template "repo/fragments/cloneDropdown" . }} 28 30 </div> 29 31 </div> ··· 71 73 onchange="window.location.href = '/{{ .RepoInfo.FullName }}/tree/' + encodeURIComponent(this.value)" 72 74 class="p-1 border max-w-32 border-gray-200 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-700" 73 75 > 74 74 - <optgroup label="branches ({{len .Branches}})" class="bold text-sm"> 76 76 + <optgroup label="{{ if .RepoInfo.IsPijul }}channels{{ else }}branches{{ end }} ({{len .Branches}})" class="bold text-sm"> 75 77 {{ range .Branches }} 76 78 <option 77 79 value="{{ .Reference.Name }}" ··· 84 86 </option> 85 87 {{ end }} 86 88 </optgroup> 89 89 + {{ if not .RepoInfo.IsPijul }} 87 90 <optgroup label="tags ({{len .Tags}})" class="bold text-sm"> 88 91 {{ range .Tags }} 89 92 <option ··· 99 102 <option class="py-1" disabled>no tags found</option> 100 103 {{ end }} 101 104 </optgroup> 105 105 + {{ end }} 102 106 </select> 103 107 <div class="flex items-center gap-2"> 104 108 <a ··· 165 169 {{ define "commitLog" }} 166 170 <div id="commit-log" class="md:col-span-1 px-2 pb-4"> 167 171 <div class="flex justify-between items-center"> 168 168 - <a href="/{{ .RepoInfo.FullName }}/commits/{{ .Ref | urlquery }}" class="flex items-center gap-2 pb-2 cursor-pointer font-bold hover:text-gray-600 dark:hover:text-gray-300 hover:no-underline"> 169 169 - {{ i "logs" "w-4 h-4" }} commits 170 170 - <span class="bg-gray-100 dark:bg-gray-700 font-normal rounded py-1/2 px-1 text-sm">{{ .TotalCommits }}</span> 171 171 - </a> 172 172 + {{ if .RepoInfo.IsPijul }} 173 173 + <a href="/{{ .RepoInfo.FullName }}/changes/{{ .Ref | urlquery }}" class="flex items-center gap-2 pb-2 cursor-pointer font-bold hover:text-gray-600 dark:hover:text-gray-300 hover:no-underline"> 174 174 + {{ i "logs" "w-4 h-4" }} changes 175 175 + <span class="bg-gray-100 dark:bg-gray-700 font-normal rounded py-1/2 px-1 text-sm">{{ .TotalCommits }}</span> 176 176 + </a> 177 177 + {{ else }} 178 178 + <a href="/{{ .RepoInfo.FullName }}/commits/{{ .Ref | urlquery }}" class="flex items-center gap-2 pb-2 cursor-pointer font-bold hover:text-gray-600 dark:hover:text-gray-300 hover:no-underline"> 179 179 + {{ i "logs" "w-4 h-4" }} commits 180 180 + <span class="bg-gray-100 dark:bg-gray-700 font-normal rounded py-1/2 px-1 text-sm">{{ .TotalCommits }}</span> 181 181 + </a> 182 182 + {{ end }} 172 183 </div> 173 184 <div class="flex flex-col gap-6"> 185 185 + {{ if .RepoInfo.IsPijul }} 186 186 + <div class="text-sm text-gray-500 dark:text-gray-400">See changes for the latest activity.</div> 187 187 + {{ else }} 174 188 {{ range .CommitsTrunc }} 175 189 <div> 176 190 <div id="commit-message"> ··· 247 261 </div> 248 262 </div> 249 263 {{ end }} 264 264 + {{ end }} 250 265 </div> 251 266 </div> 252 267 {{ end }} ··· 285 300 {{ define "branchList" }} 286 301 {{ if gt (len .BranchesTrunc) 0 }} 287 302 <div id="branches" class="md:col-span-1 px-2 py-4 border-t border-gray-200 dark:border-gray-700"> 288 288 - <a href="/{{ .RepoInfo.FullName }}/branches" class="flex items-center gap-2 pb-2 cursor-pointer font-bold hover:text-gray-600 dark:hover:text-gray-300 hover:no-underline"> 289 289 - {{ i "git-branch" "w-4 h-4" }} branches 303 303 + <a href="/{{ .RepoInfo.FullName }}/{{ if .RepoInfo.IsPijul }}channels{{ else }}branches{{ end }}" class="flex items-center gap-2 pb-2 cursor-pointer font-bold hover:text-gray-600 dark:hover:text-gray-300 hover:no-underline"> 304 304 + {{ i "git-branch" "w-4 h-4" }} {{ if .RepoInfo.IsPijul }}channels{{ else }}branches{{ end }} 290 305 <span class="bg-gray-100 dark:bg-gray-700 font-normal rounded py-1/2 px-1 text-sm">{{ len .Branches }}</span> 291 306 </a> 292 307 <div class="flex flex-col gap-1"> ··· 321 336 {{ end }} 322 337 323 338 {{ define "tagList" }} 324 324 - {{ if gt (len .TagsTrunc) 0 }} 339 339 + {{ if and (not .RepoInfo.IsPijul) (gt (len .TagsTrunc) 0) }} 325 340 <div id="tags" class="md:col-span-1 px-2 py-4 border-t border-gray-200 dark:border-gray-700"> 326 341 <div class="flex justify-between items-center"> 327 342 <a href="/{{ .RepoInfo.FullName }}/tags" class="flex items-center gap-2 pb-2 cursor-pointer font-bold hover:text-gray-600 dark:hover:text-gray-300 hover:no-underline">

+37 -1

appview/pages/templates/repo/new.html

reviewed

··· 69 69 70 70 <div class="space-y-2"> 71 71 {{ template "defaultBranch" . }} 72 72 + {{ template "vcs" . }} 72 73 {{ template "knot" . }} 73 74 </div> 74 75 </div> ··· 140 141 </div> 141 142 {{ end }} 142 143 144 144 + {{ define "vcs" }} 145 145 + <!-- Version Control --> 146 146 + <div> 147 147 + <label class="block text-sm font-bold uppercase dark:text-white mb-1"> 148 148 + Repository type 149 149 + </label> 150 150 + <div class="w-full dark:bg-gray-700 dark:text-white dark:border-gray-600 border border-gray-300 rounded p-3 space-y-2"> 151 151 + <div class="flex items-center"> 152 152 + <input 153 153 + type="radio" 154 154 + name="vcs" 155 155 + value="git" 156 156 + class="mr-2" 157 157 + id="vcs-git" 158 158 + checked 159 159 + /> 160 160 + <label for="vcs-git" class="dark:text-white">git</label> 161 161 + </div> 162 162 + <div class="flex items-center"> 163 163 + <input 164 164 + type="radio" 165 165 + name="vcs" 166 166 + value="pijul" 167 167 + class="mr-2" 168 168 + id="vcs-pijul" 169 169 + /> 170 170 + <label for="vcs-pijul" class="dark:text-white">pijul</label> 171 171 + </div> 172 172 + </div> 173 173 + <p class="text-sm text-gray-500 dark:text-gray-400 mt-1"> 174 174 + Choose the version control system for this repository. 175 175 + </p> 176 176 + </div> 177 177 + {{ end }} 178 178 + 143 179 {{ define "knot" }} 144 180 <!-- Knot Selection --> 145 181 <div> ··· 165 201 {{ end }} 166 202 </div> 167 203 <p class="text-sm text-gray-500 dark:text-gray-400 mt-1"> 168 168 - A knot hosts repository data and handles Git operations. 204 204 + A knot hosts repository data and handles version control operations. 169 205 You can also <a href="/settings/knots" class="underline">register your own knot</a>. 170 206 </p> 171 207 </div>

+120

appview/pages/templates/repo/pijul/discussions/list.html

reviewed

··· 1 1 + {{ define "title" }}discussions &middot; {{ .RepoInfo.FullName }}{{ end }} 2 2 + 3 3 + {{ define "extrameta" }} 4 4 + {{ $title := "discussions"}} 5 5 + {{ $url := printf "https://tangled.org/%s/discussions" .RepoInfo.FullName }} 6 6 + {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }} 7 7 + {{ end }} 8 8 + 9 9 + {{ define "repoContent" }} 10 10 + {{ $active := .Filter }} 11 11 + {{ if eq $active "" }} 12 12 + {{ $active = "open" }} 13 13 + {{ end }} 14 14 + 15 15 + {{ $open := 16 16 + (dict 17 17 + "Key" "open" 18 18 + "Value" "open" 19 19 + "Icon" "message-circle" 20 20 + "Meta" (string .DiscussionCount.Open)) }} 21 21 + {{ $merged := 22 22 + (dict 23 23 + "Key" "merged" 24 24 + "Value" "merged" 25 25 + "Icon" "git-merge" 26 26 + "Meta" (string .DiscussionCount.Merged)) }} 27 27 + {{ $closed := 28 28 + (dict 29 29 + "Key" "closed" 30 30 + "Value" "closed" 31 31 + "Icon" "ban" 32 32 + "Meta" (string .DiscussionCount.Closed)) }} 33 33 + {{ $values := list $open $merged $closed }} 34 34 + 35 35 + <div class="flex items-center justify-between gap-4 mb-4"> 36 36 + <div> 37 37 + {{ template "fragments/tabSelector" (dict "Name" "filter" "Values" $values "Active" $active) }} 38 38 + </div> 39 39 + <a 40 40 + href="/{{ .RepoInfo.FullName }}/discussions/new" 41 41 + class="btn-create text-sm flex items-center justify-center gap-2 no-underline hover:no-underline hover:text-white" 42 42 + > 43 43 + {{ i "message-square-plus" "w-4 h-4" }} 44 44 + <span>new discussion</span> 45 45 + </a> 46 46 + </div> 47 47 + <div class="error" id="discussions"></div> 48 48 + {{ end }} 49 49 + 50 50 + {{ define "repoAfter" }} 51 51 + <div class="mt-2"> 52 52 + {{ if .Discussions }} 53 53 + <div class="flex flex-col gap-2"> 54 54 + {{ range .Discussions }} 55 55 + {{ $stateBg := "bg-gray-800 dark:bg-gray-700" }} 56 56 + {{ $stateIcon := "ban" }} 57 57 + {{ $stateText := "closed" }} 58 58 + {{ if .State.IsOpen }} 59 59 + {{ $stateBg = "bg-green-600 dark:bg-green-700" }} 60 60 + {{ $stateIcon = "message-circle" }} 61 61 + {{ $stateText = "open" }} 62 62 + {{ else if .State.IsMerged }} 63 63 + {{ $stateBg = "bg-purple-600 dark:bg-purple-700" }} 64 64 + {{ $stateIcon = "git-merge" }} 65 65 + {{ $stateText = "merged" }} 66 66 + {{ end }} 67 67 + 68 68 + <div class="rounded drop-shadow-sm bg-white px-6 py-4 dark:bg-gray-800 dark:border-gray-700"> 69 69 + <div class="pb-2"> 70 70 + <a href="/{{ $.RepoInfo.FullName }}/discussions/{{ .DiscussionId }}" 71 71 + class="no-underline hover:underline"> 72 72 + {{ .Title | description }} 73 73 + <span class="text-gray-500 dark:text-gray-400">#{{ .DiscussionId }}</span> 74 74 + </a> 75 75 + </div> 76 76 + <div class="text-sm text-gray-500 dark:text-gray-400 flex flex-wrap items-center gap-1"> 77 77 + <span class="inline-flex items-center rounded px-2 py-[5px] {{ $stateBg }}"> 78 78 + {{ i $stateIcon "w-3 h-3 mr-1.5 text-white dark:text-white" }} 79 79 + <span class="text-white dark:text-white text-sm">{{ $stateText }}</span> 80 80 + </span> 81 81 + 82 82 + {{ if .TargetChannel }} 83 83 + <span class="inline-flex items-center rounded px-2 py-[5px] bg-blue-100 dark:bg-blue-900 text-blue-800 dark:text-blue-200 text-sm ml-1"> 84 84 + {{ i "git-branch" "w-3 h-3 mr-1" }} 85 85 + {{ .TargetChannel }} 86 86 + </span> 87 87 + {{ end }} 88 88 + 89 89 + <span class="ml-1"> 90 90 + {{ template "user/fragments/picHandleLink" .Did }} 91 91 + </span> 92 92 + 93 93 + <span class="before:content-['·']"> 94 94 + {{ template "repo/fragments/time" .Created }} 95 95 + </span> 96 96 + 97 97 + {{ $patchCount := len .ActivePatches }} 98 98 + {{ if gt $patchCount 0 }} 99 99 + <span class="before:content-['·']"> 100 100 + {{ $patchCount }} change{{ if ne $patchCount 1 }}s{{ end }} 101 101 + </span> 102 102 + {{ end }} 103 103 + 104 104 + {{ $commentCount := .TotalComments }} 105 105 + {{ if gt $commentCount 0 }} 106 106 + <span class="before:content-['·']"> 107 107 + {{ $commentCount }} comment{{ if ne $commentCount 1 }}s{{ end }} 108 108 + </span> 109 109 + {{ end }} 110 110 + </div> 111 111 + </div> 112 112 + {{ end }} 113 113 + </div> 114 114 + {{ else }} 115 115 + <div class="text-sm text-gray-500 dark:text-gray-400 text-center py-8"> 116 116 + No discussions yet. Start a new discussion to propose changes. 117 117 + </div> 118 118 + {{ end }} 119 119 + </div> 120 120 + {{ end }}

+72

appview/pages/templates/repo/pijul/discussions/new.html

reviewed

··· 1 1 + {{ define "title" }}new discussion &middot; {{ .RepoInfo.FullName }}{{ end }} 2 2 + 3 3 + {{ define "repoContent" }} 4 4 + <div class="max-w-2xl"> 5 5 + <h2 class="text-xl font-semibold mb-4">Start a new discussion</h2> 6 6 + <p class="text-sm text-gray-600 dark:text-gray-400 mb-6"> 7 7 + Discussions are for proposing changes to Pijul repositories. Anyone can add patches to a discussion. 8 8 + </p> 9 9 + 10 10 + <form 11 11 + method="POST" 12 12 + hx-post="/{{ .RepoInfo.FullName }}/discussions/new" 13 13 + hx-swap="none" 14 14 + class="flex flex-col gap-4" 15 15 + > 16 16 + <div> 17 17 + <label for="title" class="block text-sm font-medium mb-1">Title</label> 18 18 + <input 19 19 + type="text" 20 20 + id="title" 21 21 + name="title" 22 22 + required 23 23 + class="w-full px-3 py-2 border rounded border-gray-300 dark:border-gray-600 dark:bg-gray-800" 24 24 + placeholder="Discussion title" 25 25 + > 26 26 + </div> 27 27 + 28 28 + <div> 29 29 + <label for="body" class="block text-sm font-medium mb-1">Description (optional)</label> 30 30 + <textarea 31 31 + id="body" 32 32 + name="body" 33 33 + rows="6" 34 34 + class="w-full px-3 py-2 border rounded border-gray-300 dark:border-gray-600 dark:bg-gray-800 font-mono text-sm" 35 35 + placeholder="Describe your proposed changes..." 36 36 + ></textarea> 37 37 + </div> 38 38 + 39 39 + <div> 40 40 + <label for="target_channel" class="block text-sm font-medium mb-1">Target channel</label> 41 41 + <input 42 42 + type="text" 43 43 + id="target_channel" 44 44 + name="target_channel" 45 45 + value="main" 46 46 + class="w-full px-3 py-2 border rounded border-gray-300 dark:border-gray-600 dark:bg-gray-800" 47 47 + placeholder="main" 48 48 + > 49 49 + <p class="text-xs text-gray-500 dark:text-gray-400 mt-1"> 50 50 + The channel where patches should be applied when merged. 51 51 + </p> 52 52 + </div> 53 53 + 54 54 + <div class="error" id="discussion"></div> 55 55 + 56 56 + <div class="flex justify-end gap-2"> 57 57 + <a 58 58 + href="/{{ .RepoInfo.FullName }}/discussions" 59 59 + class="px-4 py-2 text-sm border rounded border-gray-300 dark:border-gray-600 hover:bg-gray-100 dark:hover:bg-gray-700 no-underline" 60 60 + > 61 61 + Cancel 62 62 + </a> 63 63 + <button 64 64 + type="submit" 65 65 + class="btn-create px-4 py-2 text-sm" 66 66 + > 67 67 + Create discussion 68 68 + </button> 69 69 + </div> 70 70 + </form> 71 71 + </div> 72 72 + {{ end }}

+264

appview/pages/templates/repo/pijul/discussions/single.html

reviewed

··· 1 1 + {{ define "title" }}{{ .Discussion.Title }} &middot; discussion #{{ .Discussion.DiscussionId }} &middot; {{ .RepoInfo.FullName }}{{ end }} 2 2 + 3 3 + {{ define "repoContentLayout" }} 4 4 + <div class="grid grid-cols-1 md:grid-cols-10 gap-4 w-full"> 5 5 + <div class="col-span-1 md:col-span-8"> 6 6 + <section class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto dark:text-white"> 7 7 + {{ block "repoContent" . }}{{ end }} 8 8 + </section> 9 9 + {{ block "repoAfter" . }}{{ end }} 10 10 + </div> 11 11 + <div class="col-span-1 md:col-span-2 flex flex-col gap-6"> 12 12 + {{ template "discussionSidebar" . }} 13 13 + </div> 14 14 + </div> 15 15 + {{ end }} 16 16 + 17 17 + {{ define "discussionSidebar" }} 18 18 + <div class="bg-white dark:bg-gray-800 rounded p-4"> 19 19 + <h3 class="text-sm font-semibold mb-2">Target Channel</h3> 20 20 + <div class="flex items-center gap-2 text-sm text-gray-600 dark:text-gray-400"> 21 21 + {{ i "git-branch" "w-4 h-4" }} 22 22 + <span>{{ .Discussion.TargetChannel }}</span> 23 23 + </div> 24 24 + </div> 25 25 + 26 26 + <div class="bg-white dark:bg-gray-800 rounded p-4"> 27 27 + <h3 class="text-sm font-semibold mb-2">Patches ({{ len .ActivePatches }})</h3> 28 28 + {{ if .ActivePatches }} 29 29 + <ul class="text-sm space-y-1"> 30 30 + {{ range .ActivePatches }} 31 31 + <li class="flex items-center gap-2 text-gray-600 dark:text-gray-400"> 32 32 + {{ i "file-diff" "w-3 h-3" }} 33 33 + <code class="text-xs">{{ .PatchHash | truncate 12 }}</code> 34 34 + </li> 35 35 + {{ end }} 36 36 + </ul> 37 37 + {{ else }} 38 38 + <p class="text-sm text-gray-500 dark:text-gray-400">No patches yet</p> 39 39 + {{ end }} 40 40 + </div> 41 41 + 42 42 + {{ template "repo/fragments/participants" .Discussion.Participants }} 43 43 + {{ end }} 44 44 + 45 45 + {{ define "repoContent" }} 46 46 + <section id="discussion-{{ .Discussion.DiscussionId }}"> 47 47 + {{ template "discussionHeader" . }} 48 48 + {{ template "discussionInfo" . }} 49 49 + {{ if .Discussion.Body }} 50 50 + <article id="body" class="mt-4 prose dark:prose-invert">{{ .Discussion.Body | markdown }}</article> 51 51 + {{ end }} 52 52 + </section> 53 53 + {{ end }} 54 54 + 55 55 + {{ define "discussionHeader" }} 56 56 + <header class="pb-2"> 57 57 + <h1 class="text-2xl"> 58 58 + {{ .Discussion.Title | description }} 59 59 + <span class="text-gray-500 dark:text-gray-400">#{{ .Discussion.DiscussionId }}</span> 60 60 + </h1> 61 61 + </header> 62 62 + {{ end }} 63 63 + 64 64 + {{ define "discussionInfo" }} 65 65 + {{ $bgColor := "bg-gray-800 dark:bg-gray-700" }} 66 66 + {{ $icon := "ban" }} 67 67 + {{ $stateText := "closed" }} 68 68 + {{ if .Discussion.State.IsOpen }} 69 69 + {{ $bgColor = "bg-green-600 dark:bg-green-700" }} 70 70 + {{ $icon = "message-circle" }} 71 71 + {{ $stateText = "open" }} 72 72 + {{ else if .Discussion.State.IsMerged }} 73 73 + {{ $bgColor = "bg-purple-600 dark:bg-purple-700" }} 74 74 + {{ $icon = "git-merge" }} 75 75 + {{ $stateText = "merged" }} 76 76 + {{ end }} 77 77 + 78 78 + <div class="inline-flex items-center gap-2 flex-wrap"> 79 79 + <span class="inline-flex items-center rounded px-2 py-[5px] {{ $bgColor }}"> 80 80 + {{ i $icon "w-3 h-3 mr-1.5 text-white dark:text-white" }} 81 81 + <span class="text-white dark:text-white text-sm">{{ $stateText }}</span> 82 82 + </span> 83 83 + 84 84 + <span class="text-gray-500 dark:text-gray-400 text-sm flex flex-wrap items-center gap-1"> 85 85 + opened by 86 86 + {{ template "user/fragments/picHandleLink" .Discussion.Did }} 87 87 + <span class="select-none before:content-['\00B7']"></span> 88 88 + {{ if .Discussion.Edited }} 89 89 + edited {{ template "repo/fragments/time" .Discussion.Edited }} 90 90 + {{ else }} 91 91 + {{ template "repo/fragments/time" .Discussion.Created }} 92 92 + {{ end }} 93 93 + </span> 94 94 + </div> 95 95 + <div id="discussion-actions-error" class="error"></div> 96 96 + {{ end }} 97 97 + 98 98 + {{ define "repoAfter" }} 99 99 + <div class="flex flex-col gap-4 mt-4"> 100 100 + <!-- Patches section --> 101 101 + <section class="bg-white dark:bg-gray-800 p-6 rounded"> 102 102 + <h3 class="text-lg font-semibold mb-4">Patches</h3> 103 103 + {{ if .Discussion.Patches }} 104 104 + <div class="space-y-3"> 105 105 + {{ range .Discussion.Patches }} 106 106 + <div class="border rounded p-4 dark:border-gray-700 {{ if not .IsActive }}opacity-50{{ end }}"> 107 107 + <div class="flex items-center justify-between"> 108 108 + <div class="flex items-center gap-2"> 109 109 + {{ i "file-diff" "w-4 h-4 text-gray-500" }} 110 110 + <code class="text-sm font-mono">{{ .PatchHash | truncate 20 }}</code> 111 111 + {{ if not .IsActive }} 112 112 + <span class="text-xs text-red-500">(removed)</span> 113 113 + {{ end }} 114 114 + </div> 115 115 + <div class="flex items-center gap-2 text-sm text-gray-500"> 116 116 + <span>by {{ template "user/fragments/picHandleLink" .PushedByDid }}</span> 117 117 + <span>{{ template "repo/fragments/time" .Added }}</span> 118 118 + </div> 119 119 + </div> 120 120 + {{ if $.CanManage }} 121 121 + <div class="mt-2 flex gap-2"> 122 122 + {{ if .IsActive }} 123 123 + <form hx-delete="/{{ $.RepoInfo.FullName }}/discussions/{{ $.Discussion.DiscussionId }}/patches/{{ .Id }}" hx-swap="none"> 124 124 + <button type="submit" class="text-xs text-red-600 hover:underline">Remove</button> 125 125 + </form> 126 126 + {{ else }} 127 127 + <form hx-post="/{{ $.RepoInfo.FullName }}/discussions/{{ $.Discussion.DiscussionId }}/patches/{{ .Id }}/readd" hx-swap="none"> 128 128 + <button type="submit" class="text-xs text-green-600 hover:underline">Re-add</button> 129 129 + </form> 130 130 + {{ end }} 131 131 + </div> 132 132 + {{ end }} 133 133 + </div> 134 134 + {{ end }} 135 135 + </div> 136 136 + {{ else }} 137 137 + <p class="text-gray-500 dark:text-gray-400 text-sm">No patches have been added to this discussion yet.</p> 138 138 + {{ end }} 139 139 + 140 140 + <!-- Add patch form --> 141 141 + {{ if and $.LoggedInUser $.Discussion.State.IsOpen }} 142 142 + <div class="mt-4 pt-4 border-t dark:border-gray-700"> 143 143 + <h4 class="text-sm font-semibold mb-2">Add a patch</h4> 144 144 + <form 145 145 + hx-post="/{{ $.RepoInfo.FullName }}/discussions/{{ $.Discussion.DiscussionId }}/patches" 146 146 + hx-swap="none" 147 147 + class="space-y-3" 148 148 + > 149 149 + <div> 150 150 + <label for="patch_hash" class="block text-xs text-gray-500 mb-1">Patch Hash</label> 151 151 + <input 152 152 + type="text" 153 153 + id="patch_hash" 154 154 + name="patch_hash" 155 155 + required 156 156 + class="w-full px-3 py-2 text-sm border rounded dark:border-gray-600 dark:bg-gray-700" 157 157 + placeholder="Pijul change hash" 158 158 + > 159 159 + </div> 160 160 + <div> 161 161 + <label for="patch" class="block text-xs text-gray-500 mb-1">Patch Content</label> 162 162 + <textarea 163 163 + id="patch" 164 164 + name="patch" 165 165 + required 166 166 + rows="4" 167 167 + class="w-full px-3 py-2 text-sm border rounded font-mono dark:border-gray-600 dark:bg-gray-700" 168 168 + placeholder="Paste your patch content here..." 169 169 + ></textarea> 170 170 + </div> 171 171 + <div class="error" id="patch"></div> 172 172 + <button type="submit" class="btn-primary text-sm px-4 py-2">Add patch</button> 173 173 + </form> 174 174 + </div> 175 175 + {{ end }} 176 176 + </section> 177 177 + 178 178 + <!-- Comments section --> 179 179 + <section class="bg-white dark:bg-gray-800 p-6 rounded"> 180 180 + <h3 class="text-lg font-semibold mb-4">Comments</h3> 181 181 + {{ if .CommentList }} 182 182 + <div class="space-y-4"> 183 183 + {{ range .CommentList }} 184 184 + <div class="border rounded p-4 dark:border-gray-700"> 185 185 + <div class="flex items-center gap-2 text-sm text-gray-500 mb-2"> 186 186 + {{ template "user/fragments/picHandleLink" .Self.Did }} 187 187 + <span>{{ template "repo/fragments/time" .Self.Created }}</span> 188 188 + </div> 189 189 + <div class="prose dark:prose-invert">{{ .Self.Body | markdown }}</div> 190 190 + {{ if .Replies }} 191 191 + <div class="mt-4 ml-4 space-y-3 border-l-2 border-gray-200 dark:border-gray-600 pl-4"> 192 192 + {{ range .Replies }} 193 193 + <div class="text-sm"> 194 194 + <div class="flex items-center gap-2 text-gray-500 mb-1"> 195 195 + {{ template "user/fragments/picHandleLink" .Did }} 196 196 + <span>{{ template "repo/fragments/time" .Created }}</span> 197 197 + </div> 198 198 + <div class="prose dark:prose-invert prose-sm">{{ .Body | markdown }}</div> 199 199 + </div> 200 200 + {{ end }} 201 201 + </div> 202 202 + {{ end }} 203 203 + </div> 204 204 + {{ end }} 205 205 + </div> 206 206 + {{ else }} 207 207 + <p class="text-gray-500 dark:text-gray-400 text-sm">No comments yet.</p> 208 208 + {{ end }} 209 209 + 210 210 + <!-- New comment form --> 211 211 + {{ if $.LoggedInUser }} 212 212 + <div class="mt-4 pt-4 border-t dark:border-gray-700"> 213 213 + <form 214 214 + hx-post="/{{ $.RepoInfo.FullName }}/discussions/{{ $.Discussion.DiscussionId }}/comment" 215 215 + hx-swap="none" 216 216 + class="space-y-3" 217 217 + > 218 218 + <textarea 219 219 + name="body" 220 220 + required 221 221 + rows="3" 222 222 + class="w-full px-3 py-2 text-sm border rounded dark:border-gray-600 dark:bg-gray-700" 223 223 + placeholder="Add a comment..." 224 224 + ></textarea> 225 225 + <div class="error" id="comment"></div> 226 226 + <button type="submit" class="btn-primary text-sm px-4 py-2">Comment</button> 227 227 + </form> 228 228 + </div> 229 229 + {{ end }} 230 230 + </section> 231 231 + 232 232 + <!-- Discussion actions --> 233 233 + {{ if $.LoggedInUser }} 234 234 + <section class="bg-white dark:bg-gray-800 p-6 rounded"> 235 235 + <div class="flex flex-wrap gap-2"> 236 236 + {{ if $.Discussion.State.IsOpen }} 237 237 + {{ if $.CanManage }} 238 238 + <form hx-post="/{{ $.RepoInfo.FullName }}/discussions/{{ $.Discussion.DiscussionId }}/merge" hx-swap="none"> 239 239 + <button type="submit" class="btn-create text-sm px-4 py-2 flex items-center gap-2"> 240 240 + {{ i "git-merge" "w-4 h-4" }} 241 241 + Merge 242 242 + </button> 243 243 + </form> 244 244 + {{ end }} 245 245 + <form hx-post="/{{ $.RepoInfo.FullName }}/discussions/{{ $.Discussion.DiscussionId }}/close" hx-swap="none"> 246 246 + <button type="submit" class="btn-secondary text-sm px-4 py-2 flex items-center gap-2"> 247 247 + {{ i "ban" "w-4 h-4" }} 248 248 + Close 249 249 + </button> 250 250 + </form> 251 251 + {{ else if $.Discussion.State.IsClosed }} 252 252 + <form hx-post="/{{ $.RepoInfo.FullName }}/discussions/{{ $.Discussion.DiscussionId }}/reopen" hx-swap="none"> 253 253 + <button type="submit" class="btn-primary text-sm px-4 py-2 flex items-center gap-2"> 254 254 + {{ i "refresh-cw" "w-4 h-4" }} 255 255 + Reopen 256 256 + </button> 257 257 + </form> 258 258 + {{ end }} 259 259 + </div> 260 260 + <div class="error" id="discussion"></div> 261 261 + </section> 262 262 + {{ end }} 263 263 + </div> 264 264 + {{ end }}

+1 -2

appview/pages/templates/repo/settings/general.html

reviewed

··· 97 97 <div class="col-span-1 md:col-span-2"> 98 98 <h2 class="text-sm pb-2 uppercase font-bold">Default Labels</h2> 99 99 <p class="text-gray-500 dark:text-gray-400"> 100 100 - Manage your issues and pulls by creating labels to categorize them. Only 100 100 + Manage your {{ if .RepoInfo.IsPijul }}discussions{{ else }}issues and pulls{{ end }} by creating labels to categorize them. Only 101 101 repository owners may configure labels. You may choose to subscribe to 102 102 default labels, or create entirely custom labels. 103 103 <p> ··· 240 240 </div> 241 241 {{ end }} 242 242 {{ end }} 243 243 -

+40 -40

appview/repo/blob.go

reviewed

··· 11 11 "strings" 12 12 "time" 13 13 14 14 + indigoxrpc "github.com/bluesky-social/indigo/xrpc" 15 15 + "github.com/go-chi/chi/v5" 16 16 + "github.com/go-git/go-git/v5/plumbing" 14 17 "tangled.org/core/api/tangled" 15 18 "tangled.org/core/appview/config" 16 19 "tangled.org/core/appview/db" ··· 18 21 "tangled.org/core/appview/pages" 19 22 "tangled.org/core/appview/pages/markup" 20 23 "tangled.org/core/appview/reporesolver" 21 21 - xrpcclient "tangled.org/core/appview/xrpcclient" 22 24 "tangled.org/core/types" 25 25 + ) 23 26 24 24 - indigoxrpc "github.com/bluesky-social/indigo/xrpc" 25 25 - "github.com/go-chi/chi/v5" 26 26 - "github.com/go-git/go-git/v5/plumbing" 27 27 - ) 27 27 + // knotXrpcc builds an XRPC client that points directly at the knot hosting f. 28 28 + func (rp *Repo) knotXrpcc(knot string) *indigoxrpc.Client { 29 29 + scheme := "http" 30 30 + if !rp.config.Core.Dev { 31 31 + scheme = "https" 32 32 + } 33 33 + return &indigoxrpc.Client{Host: fmt.Sprintf("%s://%s", scheme, knot)} 34 34 + } 28 35 29 36 // the content can be one of the following: 30 37 // ··· 50 57 filePath := chi.URLParam(r, "*") 51 58 filePath, _ = url.PathUnescape(filePath) 52 59 53 53 - scheme := "http" 54 54 - if !rp.config.Core.Dev { 55 55 - scheme = "https" 56 56 - } 57 57 - host := fmt.Sprintf("%s://%s", scheme, f.Knot) 58 58 - xrpcc := &indigoxrpc.Client{ 59 59 - Host: host, 60 60 - } 61 61 - resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, f.RepoIdentifier()) 62 62 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 63 63 - l.Error("failed to call XRPC repo.blob", "err", xrpcerr) 60 60 + provider := newVcsProvider(f, rp.knotXrpcc(f.Knot)) 61 61 + 62 62 + resp, err := provider.GetBlob(r.Context(), ref, filePath) 63 63 + if err != nil { 64 64 + l.Error("failed to fetch blob", "err", err) 64 65 rp.pages.Error503(w) 65 66 return 66 67 } 67 68 68 69 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f) 69 70 70 70 - // Use XRPC response directly instead of converting to internal types 71 71 var breadcrumbs [][]string 72 72 breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", ownerSlashRepo, url.PathEscape(ref))}) 73 73 if filePath != "" { ··· 76 76 } 77 77 } 78 78 79 79 - // Create the blob view 80 79 blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query()) 81 80 82 81 user := rp.oauth.GetMultiAccountUser(r) 83 82 84 84 - // Get email to DID mapping for commit author 85 83 var emails []string 86 84 if resp.LastCommit != nil && resp.LastCommit.Author != nil { 87 85 emails = append(emails, resp.LastCommit.Author.Email) ··· 138 136 if !rp.config.Core.Dev { 139 137 scheme = "https" 140 138 } 141 141 - repo := f.RepoIdentifier() 139 139 + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) 140 140 + 141 141 + provider := newVcsProvider(f, rp.knotXrpcc(f.Knot)) 142 142 baseURL := &url.URL{ 143 143 Scheme: scheme, 144 144 Host: f.Knot, 145 145 - Path: "/xrpc/sh.tangled.repo.blob", 145 145 + Path: provider.RawBlobXrpcPath(), 146 146 } 147 147 query := baseURL.Query() 148 148 - query.Set("repo", repo) 149 149 - query.Set("ref", ref) 150 150 - query.Set("path", filePath) 151 151 - query.Set("raw", "true") 148 148 + provider.SetRawBlobQuery(query, ref, filePath, repo) 152 149 baseURL.RawQuery = query.Encode() 150 150 + 153 151 blobURL := baseURL.String() 154 152 req, err := http.NewRequest("GET", blobURL, nil) 155 153 if err != nil { ··· 157 155 return 158 156 } 159 157 160 160 - // forward the If-None-Match header 161 158 if clientETag := r.Header.Get("If-None-Match"); clientETag != "" { 162 159 req.Header.Set("If-None-Match", clientETag) 163 160 } ··· 169 166 rp.pages.Error503(w) 170 167 return 171 168 } 172 172 - 173 169 defer resp.Body.Close() 174 170 175 175 - // forward 304 not modified 176 171 if resp.StatusCode == http.StatusNotModified { 177 172 w.WriteHeader(http.StatusNotModified) 178 173 return ··· 194 189 } 195 190 196 191 if strings.HasPrefix(contentType, "text/") || isTextualMimeType(contentType) { 197 197 - // serve all textual content as text/plain 198 192 w.Header().Set("Content-Type", "text/plain; charset=utf-8") 199 193 w.Write(body) 200 194 } else if strings.HasPrefix(contentType, "image/") || strings.HasPrefix(contentType, "video/") { 201 201 - // serve images and videos with their original content type 202 195 w.Header().Set("Content-Type", contentType) 203 196 w.Write(body) 204 197 } else { 205 198 w.WriteHeader(http.StatusUnsupportedMediaType) 206 199 w.Write([]byte("unsupported content type")) 207 207 - return 208 200 } 209 201 } 210 202 ··· 215 207 Lines: 0, 216 208 } 217 209 218 218 - // Set size 219 210 if resp.Size != nil { 220 211 view.SizeHint = uint64(*resp.Size) 221 212 } else if resp.Content != nil { ··· 229 220 return view 230 221 } 231 222 232 232 - // Determine if binary 233 223 if resp.IsBinary != nil && *resp.IsBinary { 234 224 view.ContentSrc = generateBlobURL(config, repo, ref, filePath) 235 225 ext := strings.ToLower(filepath.Ext(resp.Path)) ··· 263 253 return view 264 254 } 265 255 266 266 - // otherwise, we are dealing with text content 267 256 view.HasRawView = true 268 257 view.HasTextView = true 269 258 ··· 272 261 view.Lines = countLines(view.Contents) 273 262 } 274 263 275 275 - // with text, we may be dealing with markdown 276 264 format := markup.GetFormat(resp.Path) 277 265 if format == markup.FormatMarkdown { 278 266 view.ContentType = models.BlobContentTypeMarkup ··· 289 277 scheme = "https" 290 278 } 291 279 292 292 - repoName := repo.RepoIdentifier() 280 280 + var xrpcPath, refParam string 281 281 + repoId := fmt.Sprintf("%s/%s", repo.Did, repo.Name) 282 282 + if repo.IsPijul() { 283 283 + xrpcPath = "/xrpc/sh.tangled.repo.pijulBlob" 284 284 + refParam = "channel" 285 285 + } else { 286 286 + xrpcPath = "/xrpc/sh.tangled.repo.blob" 287 287 + refParam = "ref" 288 288 + repoId = repo.RepoIdentifier() 289 289 + } 290 290 + 293 291 baseURL := &url.URL{ 294 292 Scheme: scheme, 295 293 Host: repo.Knot, 296 296 - Path: "/xrpc/sh.tangled.repo.blob", 294 294 + Path: xrpcPath, 297 295 } 298 296 query := baseURL.Query() 299 299 - query.Set("repo", repoName) 300 300 - query.Set("ref", ref) 297 297 + query.Set("repo", repoId) 298 298 + query.Set(refParam, ref) 301 299 query.Set("path", filePath) 302 302 - query.Set("raw", "true") 300 300 + if !repo.IsPijul() { 301 301 + query.Set("raw", "true") 302 302 + } 303 303 baseURL.RawQuery = query.Encode() 304 304 blobURL := baseURL.String() 305 305

+351

appview/repo/changes.go

reviewed

··· 1 1 + package repo 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "net/http" 6 6 + "net/url" 7 7 + "strconv" 8 8 + "strings" 9 9 + "time" 10 10 + 11 11 + "tangled.org/core/api/tangled" 12 12 + "tangled.org/core/appview/oauth" 13 13 + "tangled.org/core/appview/pages" 14 14 + xrpcclient "tangled.org/core/appview/xrpcclient" 15 15 + 16 16 + "github.com/go-chi/chi/v5" 17 17 + ) 18 18 + 19 19 + func (rp *Repo) Changes(w http.ResponseWriter, r *http.Request) { 20 20 + l := rp.logger.With("handler", "RepoChanges") 21 21 + 22 22 + f, err := rp.repoResolver.Resolve(r) 23 23 + if err != nil { 24 24 + l.Error("failed to fully resolve repo", "err", err) 25 25 + return 26 26 + } 27 27 + if !f.IsPijul() { 28 28 + rp.pages.Error404(w) 29 29 + return 30 30 + } 31 31 + 32 32 + page := 1 33 33 + if r.URL.Query().Get("page") != "" { 34 34 + page, err = strconv.Atoi(r.URL.Query().Get("page")) 35 35 + if err != nil { 36 36 + page = 1 37 37 + } 38 38 + } 39 39 + 40 40 + ref := chi.URLParam(r, "ref") 41 41 + ref, _ = url.PathUnescape(ref) 42 42 + 43 43 + xrpcc := rp.knotXrpcc(f.Knot) 44 44 + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) 45 45 + 46 46 + if ref == "" { 47 47 + channels, err := tangled.RepoChannelList(r.Context(), xrpcc, "", 0, repo) 48 48 + if err != nil { 49 49 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 50 50 + l.Error("failed to call XRPC repo.channelList", "err", xrpcerr) 51 51 + rp.pages.Error503(w) 52 52 + return 53 53 + } 54 54 + rp.pages.Error503(w) 55 55 + return 56 56 + } 57 57 + for _, ch := range channels.Channels { 58 58 + if ch.Is_current != nil && *ch.Is_current { 59 59 + ref = ch.Name 60 60 + break 61 61 + } 62 62 + } 63 63 + if ref == "" && len(channels.Channels) > 0 { 64 64 + ref = channels.Channels[0].Name 65 65 + } 66 66 + } 67 67 + 68 68 + limit := int64(60) 69 69 + cursor := "" 70 70 + if page > 1 { 71 71 + offset := (page - 1) * int(limit) 72 72 + cursor = strconv.Itoa(offset) 73 73 + } 74 74 + 75 75 + resp, err := tangled.RepoChangeList(r.Context(), xrpcc, ref, cursor, limit, repo) 76 76 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 77 77 + l.Error("failed to call XRPC repo.changeList", "err", xrpcerr) 78 78 + rp.pages.Error503(w) 79 79 + return 80 80 + } 81 81 + 82 82 + changes := make([]pages.PijulChangeView, 0, len(resp.Changes)) 83 83 + for _, change := range resp.Changes { 84 84 + view := pages.PijulChangeView{ 85 85 + Hash: change.Hash, 86 86 + Authors: change.Authors, 87 87 + Message: change.Message, 88 88 + Dependencies: change.Dependencies, 89 89 + } 90 90 + if change.Timestamp != nil { 91 91 + if parsed, err := time.Parse(time.RFC3339, *change.Timestamp); err == nil { 92 92 + view.Timestamp = parsed 93 93 + view.HasTimestamp = true 94 94 + } 95 95 + } 96 96 + changes = append(changes, view) 97 97 + } 98 98 + 99 99 + user := rp.oauth.GetMultiAccountUser(r) 100 100 + rp.pages.RepoChanges(w, pages.RepoChangesParams{ 101 101 + LoggedInUser: user, 102 102 + RepoInfo: rp.repoResolver.GetRepoInfo(r, user), 103 103 + Page: page, 104 104 + Changes: changes, 105 105 + }) 106 106 + } 107 107 + 108 108 + func (rp *Repo) Change(w http.ResponseWriter, r *http.Request) { 109 109 + l := rp.logger.With("handler", "RepoChange") 110 110 + 111 111 + f, err := rp.repoResolver.Resolve(r) 112 112 + if err != nil { 113 113 + l.Error("failed to fully resolve repo", "err", err) 114 114 + return 115 115 + } 116 116 + if !f.IsPijul() { 117 117 + rp.pages.Error404(w) 118 118 + return 119 119 + } 120 120 + 121 121 + hash := chi.URLParam(r, "hash") 122 122 + if hash == "" { 123 123 + rp.pages.Error404(w) 124 124 + return 125 125 + } 126 126 + 127 127 + xrpcc := rp.knotXrpcc(f.Knot) 128 128 + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) 129 129 + resp, err := tangled.RepoChangeGet(r.Context(), xrpcc, hash, repo) 130 130 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 131 131 + l.Error("failed to call XRPC repo.changeGet", "err", xrpcerr) 132 132 + rp.pages.Error503(w) 133 133 + return 134 134 + } 135 135 + 136 136 + change := pages.PijulChangeDetail{ 137 137 + Hash: resp.Hash, 138 138 + Authors: resp.Authors, 139 139 + Message: resp.Message, 140 140 + Dependencies: resp.Dependencies, 141 141 + } 142 142 + if resp.Diff != nil { 143 143 + change.Diff = *resp.Diff 144 144 + change.HasDiff = true 145 145 + change.DiffLines = parsePijulDiffLines(change.Diff) 146 146 + } 147 147 + if resp.Timestamp != nil { 148 148 + if parsed, err := time.Parse(time.RFC3339, *resp.Timestamp); err == nil { 149 149 + change.Timestamp = parsed 150 150 + change.HasTimestamp = true 151 151 + } 152 152 + } 153 153 + 154 154 + user := rp.oauth.GetMultiAccountUser(r) 155 155 + rp.pages.RepoChange(w, pages.RepoChangeParams{ 156 156 + LoggedInUser: user, 157 157 + RepoInfo: rp.repoResolver.GetRepoInfo(r, user), 158 158 + Change: change, 159 159 + }) 160 160 + } 161 161 + 162 162 + func parsePijulDiffLines(diff string) []pages.PijulDiffLine { 163 163 + if diff == "" { 164 164 + return nil 165 165 + } 166 166 + lines := strings.Split(diff, "\n") 167 167 + out := make([]pages.PijulDiffLine, 0, len(lines)) 168 168 + var oldLine int64 169 169 + var newLine int64 170 170 + var hasOld bool 171 171 + var hasNew bool 172 172 + for _, line := range lines { 173 173 + kind := "context" 174 174 + op := " " 175 175 + body := line 176 176 + switch { 177 177 + case strings.HasPrefix(line, "+++ ") || strings.HasPrefix(line, "--- "): 178 178 + kind = "meta" 179 179 + op = "" 180 180 + hasOld = false 181 181 + hasNew = false 182 182 + case strings.HasPrefix(line, "@@"): 183 183 + kind = "meta" 184 184 + op = "" 185 185 + if o, n, ok := parseUnifiedHunkHeader(line); ok { 186 186 + oldLine = o 187 187 + newLine = n 188 188 + hasOld = true 189 189 + hasNew = true 190 190 + } else { 191 191 + hasOld = false 192 192 + hasNew = false 193 193 + } 194 194 + case strings.HasPrefix(line, "diff ") || strings.HasPrefix(line, "index "): 195 195 + kind = "meta" 196 196 + op = "" 197 197 + hasOld = false 198 198 + hasNew = false 199 199 + case strings.HasPrefix(line, "#"): 200 200 + kind = "section" 201 201 + op = "" 202 202 + hasOld = false 203 203 + hasNew = false 204 204 + case strings.HasPrefix(line, "+") && !strings.HasPrefix(line, "+++"): 205 205 + kind = "add" 206 206 + op = "+" 207 207 + body = line[1:] 208 208 + case strings.HasPrefix(line, "-") && !strings.HasPrefix(line, "---"): 209 209 + kind = "del" 210 210 + op = "-" 211 211 + body = line[1:] 212 212 + case strings.HasPrefix(line, " "): 213 213 + body = line[1:] 214 214 + } 215 215 + diffLine := pages.PijulDiffLine{ 216 216 + Kind: kind, 217 217 + Op: op, 218 218 + Body: body, 219 219 + Text: line, 220 220 + } 221 221 + if kind != "meta" { 222 222 + if kind == "del" { 223 223 + if hasOld { 224 224 + diffLine.OldLine = oldLine 225 225 + diffLine.HasOld = true 226 226 + oldLine++ 227 227 + } 228 228 + } else if kind == "add" { 229 229 + if hasNew { 230 230 + diffLine.NewLine = newLine 231 231 + diffLine.HasNew = true 232 232 + newLine++ 233 233 + } 234 234 + } else { 235 235 + if hasOld { 236 236 + diffLine.OldLine = oldLine 237 237 + diffLine.HasOld = true 238 238 + oldLine++ 239 239 + } 240 240 + if hasNew { 241 241 + diffLine.NewLine = newLine 242 242 + diffLine.HasNew = true 243 243 + newLine++ 244 244 + } 245 245 + } 246 246 + } 247 247 + out = append(out, diffLine) 248 248 + } 249 249 + return out 250 250 + } 251 251 + 252 252 + func parseUnifiedHunkHeader(line string) (int64, int64, bool) { 253 253 + start := strings.Index(line, "@@") 254 254 + if start == -1 { 255 255 + return 0, 0, false 256 256 + } 257 257 + trimmed := strings.TrimSpace(line[start+2:]) 258 258 + end := strings.Index(trimmed, "@@") 259 259 + if end == -1 { 260 260 + return 0, 0, false 261 261 + } 262 262 + fields := strings.Fields(strings.TrimSpace(trimmed[:end])) 263 263 + if len(fields) < 2 { 264 264 + return 0, 0, false 265 265 + } 266 266 + oldStart, okOld := parseUnifiedRange(fields[0], "-") 267 267 + newStart, okNew := parseUnifiedRange(fields[1], "+") 268 268 + if !okOld || !okNew { 269 269 + return 0, 0, false 270 270 + } 271 271 + return oldStart, newStart, true 272 272 + } 273 273 + 274 274 + func parseUnifiedRange(value, prefix string) (int64, bool) { 275 275 + if !strings.HasPrefix(value, prefix) { 276 276 + return 0, false 277 277 + } 278 278 + value = strings.TrimPrefix(value, prefix) 279 279 + if value == "" { 280 280 + return 0, false 281 281 + } 282 282 + if idx := strings.Index(value, ","); idx >= 0 { 283 283 + value = value[:idx] 284 284 + } 285 285 + out, err := strconv.ParseInt(value, 10, 64) 286 286 + if err != nil { 287 287 + return 0, false 288 288 + } 289 289 + return out, true 290 290 + } 291 291 + 292 292 + func (rp *Repo) UnrecordChange(w http.ResponseWriter, r *http.Request) { 293 293 + l := rp.logger.With("handler", "UnrecordChange") 294 294 + 295 295 + f, err := rp.repoResolver.Resolve(r) 296 296 + if err != nil { 297 297 + l.Error("failed to resolve repo", "err", err) 298 298 + rp.pages.Notice(w, "change", "Failed to resolve repository") 299 299 + return 300 300 + } 301 301 + if !f.IsPijul() { 302 302 + rp.pages.Notice(w, "change", "Unrecord is only available for Pijul repositories") 303 303 + return 304 304 + } 305 305 + 306 306 + hash := chi.URLParam(r, "hash") 307 307 + if hash == "" { 308 308 + rp.pages.Notice(w, "change", "Missing change hash") 309 309 + return 310 310 + } 311 311 + 312 312 + user := rp.oauth.GetMultiAccountUser(r) 313 313 + repoInfo := rp.repoResolver.GetRepoInfo(r, user) 314 314 + if !repoInfo.Roles.CanManageRepo() { 315 315 + rp.pages.Notice(w, "change", "You don't have permission to unrecord changes") 316 316 + return 317 317 + } 318 318 + 319 319 + xrpcc, err := rp.oauth.ServiceClient( 320 320 + r, 321 321 + oauth.WithService(f.Knot), 322 322 + oauth.WithLxm(tangled.RepoUnrecordChangesNSID), 323 323 + oauth.WithDev(rp.config.Core.Dev), 324 324 + ) 325 325 + if err != nil { 326 326 + l.Error("failed to create service client", "err", err) 327 327 + rp.pages.Notice(w, "change", "Failed to authenticate with knotserver") 328 328 + return 329 329 + } 330 330 + 331 331 + repoIdentifier := fmt.Sprintf("%s/%s", f.Did, f.Name) 332 332 + input := &tangled.RepoUnrecordChanges_Input{ 333 333 + Repo: repoIdentifier, 334 334 + Changes: []string{hash}, 335 335 + } 336 336 + 337 337 + result, err := tangled.RepoUnrecordChanges(r.Context(), xrpcc, input) 338 338 + if err != nil { 339 339 + l.Error("failed to unrecord change", "err", err) 340 340 + rp.pages.Notice(w, "change", "Failed to unrecord change: "+err.Error()) 341 341 + return 342 342 + } 343 343 + 344 344 + if len(result.Failed) > 0 { 345 345 + rp.pages.Notice(w, "change", "Failed to unrecord change: "+result.Failed[0].Error) 346 346 + return 347 347 + } 348 348 + 349 349 + l.Info("change unrecorded", "hash", hash) 350 350 + rp.pages.HxLocation(w, fmt.Sprintf("/%s/%s/changes", f.Did, f.Name)) 351 351 + }

+71 -2

appview/repo/index.go

reviewed

··· 43 43 44 44 user := rp.oauth.GetMultiAccountUser(r) 45 45 46 46 - // Build index response from multiple XRPC calls 47 47 - result, err := rp.buildIndexResponse(r.Context(), f, ref) 46 46 + var result *types.RepoIndexResponse 47 47 + if f.IsPijul() { 48 48 + result, err = rp.buildPijulIndexResponse(r.Context(), f, ref) 49 49 + } else { 50 50 + result, err = rp.buildIndexResponse(r.Context(), f, ref) 51 51 + } 48 52 if err != nil { 49 53 l.Error("failed to build index response", "err", err) 50 54 rp.pages.RepoIndexPage(w, pages.RepoIndexParams{ ··· 155 159 currentRef string, 156 160 isDefaultRef bool, 157 161 ) ([]types.RepoLanguageDetails, error) { 162 162 + if repo.IsPijul() { 163 163 + return nil, nil 164 164 + } 158 165 // first attempt to fetch from db 159 166 langs, err := db.GetRepoLanguages( 160 167 rp.db, ··· 365 372 366 373 return result, nil 367 374 } 375 375 + 376 376 + // buildPijulIndexResponse builds a RepoIndexResponse for a pijul repository. 377 377 + func (rp *Repo) buildPijulIndexResponse(ctx context.Context, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) { 378 378 + xrpcc := rp.knotXrpcc(repo.Knot) 379 379 + repoId := fmt.Sprintf("%s/%s", repo.Did, repo.Name) 380 380 + 381 381 + // Fetch channels to determine the active ref and populate the branch selector. 382 382 + channels, err := tangled.RepoChannelList(ctx, xrpcc, "", 0, repoId) 383 383 + if err != nil { 384 384 + return nil, fmt.Errorf("calling repo.channelList: %w", err) 385 385 + } 386 386 + 387 387 + if len(channels.Channels) == 0 { 388 388 + return &types.RepoIndexResponse{IsEmpty: true}, nil 389 389 + } 390 390 + 391 391 + // Resolve ref: use provided, or current channel, or first available. 392 392 + if ref == "" { 393 393 + for _, ch := range channels.Channels { 394 394 + if ch.Is_current != nil && *ch.Is_current { 395 395 + ref = ch.Name 396 396 + break 397 397 + } 398 398 + } 399 399 + if ref == "" { 400 400 + ref = channels.Channels[0].Name 401 401 + } 402 402 + } 403 403 + 404 404 + branches := make([]types.Branch, 0, len(channels.Channels)) 405 405 + for _, ch := range channels.Channels { 406 406 + isCurrent := ch.Is_current != nil && *ch.Is_current 407 407 + branches = append(branches, types.Branch{ 408 408 + Reference: types.Reference{Name: ch.Name}, 409 409 + IsDefault: isCurrent, 410 410 + }) 411 411 + } 412 412 + 413 413 + provider := newVcsProvider(repo, xrpcc) 414 414 + treeResult, _, err := provider.GetTree(ctx, ref, "") 415 415 + if err != nil { 416 416 + return nil, fmt.Errorf("fetching pijul tree: %w", err) 417 417 + } 418 418 + 419 419 + // Fetch total change count for the active channel. 420 420 + changeResp, err := tangled.RepoChangeList(ctx, xrpcc, ref, "", 1, repoId) 421 421 + var totalChanges int 422 422 + if err == nil { 423 423 + totalChanges = int(changeResp.Total) 424 424 + } 425 425 + 426 426 + return &types.RepoIndexResponse{ 427 427 + IsEmpty: false, 428 428 + Ref: ref, 429 429 + Files: treeResult.Files, 430 430 + Readme: treeResult.Readme, 431 431 + ReadmeFileName: treeResult.ReadmeFileName, 432 432 + Branches: branches, 433 433 + TotalCommits: totalChanges, 434 434 + }, nil 435 435 + } 436 436 +

+2 -3

appview/repo/repo.go

reviewed

··· 799 799 fail("Failed to add collaborator permissions.", err) 800 800 return 801 801 } 802 802 - 803 802 err = db.AddCollaborator(tx, models.Collaborator{ 804 803 Did: syntax.DID(currentUser.Active.Did), 805 804 Rkey: rkey, ··· 917 916 rp.pages.Notice(w, noticeId, "Failed to update RBAC rules") 918 917 return 919 918 } 920 920 - 921 919 // remove repo from db 922 920 err = db.RemoveRepo(tx, f.Did, f.Name) 923 921 if err != nil { ··· 1090 1088 Rkey: rkey, 1091 1089 Name: forkName, 1092 1090 Source: &forkSourceUrl, 1091 1091 + Vcs: &f.Vcs, 1093 1092 } 1094 1093 createResp, createErr := tangled.RepoCreate( 1095 1094 r.Context(), ··· 1126 1125 Created: time.Now(), 1127 1126 Labels: rp.config.Label.DefaultLabelDefs, 1128 1127 RepoDid: repoDid, 1128 1128 + Vcs: f.Vcs, 1129 1129 } 1130 1130 record := repo.AsRecord() 1131 1131 ··· 1230 1230 rp.pages.Notice(w, "repo", "Failed to set up repository permissions.") 1231 1231 return 1232 1232 } 1233 1233 - 1234 1233 err = tx.Commit() 1235 1234 if err != nil { 1236 1235 l.Error("failed to commit changes", "err", err)

+8

appview/repo/router.go

reviewed

··· 13 13 r.Get("/opengraph", rp.Opengraph) 14 14 r.Get("/feed.atom", rp.AtomFeed) 15 15 r.Get("/commits/{ref}", rp.Log) 16 16 + r.Get("/changes", rp.Changes) 17 17 + r.Get("/changes/{ref}", rp.Changes) 16 18 r.Route("/tree/{ref}", func(r chi.Router) { 17 19 r.Get("/", rp.Index) 18 20 r.Get("/*", rp.Tree) 19 21 }) 20 22 r.Get("/commit/{ref}", rp.Commit) 23 23 + r.Get("/change/{hash}", rp.Change) 24 24 + r.Group(func(r chi.Router) { 25 25 + r.Use(middleware.AuthMiddleware(rp.oauth)) 26 26 + r.Use(mw.RepoPermissionMiddleware("repo:push")) 27 27 + r.Post("/change/{hash}/unrecord", rp.UnrecordChange) 28 28 + }) 21 29 r.Get("/branches", rp.Branches) 22 30 r.Delete("/branches", rp.DeleteBranch) 23 31 r.Route("/tags", func(r chi.Router) {

+9 -4

appview/repo/tags.go

reviewed

··· 27 27 l.Error("failed to get repo and knot", "err", err) 28 28 return 29 29 } 30 30 - xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url} 31 31 - xrpcBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoAt().String()) 32 32 - if err != nil { 33 33 - l.Error("failed to call XRPC repo.tags", "err", err) 30 30 + if f.IsPijul() { 31 31 + rp.pages.Error404(w) 32 32 + return 33 33 + } 34 34 + xrpcc := rp.knotXrpcc(f.Knot) 35 35 + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) 36 36 + xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 37 37 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 38 38 + l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 34 39 rp.pages.Error503(w) 35 40 return 36 41 }

+28 -72

appview/repo/tree.go

reviewed

··· 5 5 "net/http" 6 6 "net/url" 7 7 "strings" 8 8 - "time" 9 8 10 10 - "tangled.org/core/api/tangled" 9 9 + "github.com/go-chi/chi/v5" 11 10 "tangled.org/core/appview/db" 12 11 "tangled.org/core/appview/pages" 13 12 "tangled.org/core/appview/reporesolver" 14 14 - xrpcclient "tangled.org/core/appview/xrpcclient" 15 15 - "tangled.org/core/types" 16 16 - 17 17 - indigoxrpc "github.com/bluesky-social/indigo/xrpc" 18 18 - "github.com/go-chi/chi/v5" 19 19 - "github.com/go-git/go-git/v5/plumbing" 20 13 ) 21 14 22 15 func (rp *Repo) Tree(w http.ResponseWriter, r *http.Request) { ··· 34 27 treePath, _ = url.PathUnescape(treePath) 35 28 treePath = strings.TrimSuffix(treePath, "/") 36 29 37 37 - xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url} 38 38 - xrpcResp, err := tangled.GitTempGetTree(r.Context(), xrpcc, treePath, ref, f.RepoAt().String()) 39 39 - if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 40 40 - l.Error("failed to call XRPC repo.tree", "err", xrpcerr) 30 30 + provider := newVcsProvider(f, rp.knotXrpcc(f.Knot)) 31 31 + 32 32 + result, lastCommit, err := provider.GetTree(r.Context(), ref, treePath) 33 33 + if err != nil { 34 34 + l.Error("failed to fetch tree", "err", err) 41 35 rp.pages.Error503(w) 42 36 return 43 37 } 44 44 - // Convert XRPC response to internal types.RepoTreeResponse 45 45 - files := make([]types.NiceTree, len(xrpcResp.Files)) 46 46 - for i, xrpcFile := range xrpcResp.Files { 47 47 - file := types.NiceTree{ 48 48 - Name: xrpcFile.Name, 49 49 - Mode: xrpcFile.Mode, 50 50 - Size: int64(xrpcFile.Size), 51 51 - } 52 52 - // Convert last commit info if present 53 53 - if xrpcFile.Last_commit != nil { 54 54 - commitWhen, _ := time.Parse(time.RFC3339, xrpcFile.Last_commit.When) 55 55 - file.LastCommit = &types.LastCommitInfo{ 56 56 - Hash: plumbing.NewHash(xrpcFile.Last_commit.Hash), 57 57 - Message: xrpcFile.Last_commit.Message, 58 58 - When: commitWhen, 59 59 - } 60 60 - } 61 61 - files[i] = file 62 62 - } 63 63 - result := types.RepoTreeResponse{ 64 64 - Ref: xrpcResp.Ref, 65 65 - Files: files, 66 66 - } 67 67 - if xrpcResp.Parent != nil { 68 68 - result.Parent = *xrpcResp.Parent 69 69 - } 70 70 - if xrpcResp.Dotdot != nil { 71 71 - result.DotDot = *xrpcResp.Dotdot 72 72 - } 73 73 - if xrpcResp.Readme != nil { 74 74 - result.ReadmeFileName = xrpcResp.Readme.Filename 75 75 - result.Readme = xrpcResp.Readme.Contents 38 38 + 39 39 + ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f) 40 40 + 41 41 + displayRef := ref 42 42 + if displayRef == "" { 43 43 + displayRef = result.Ref 76 44 } 77 77 - ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f) 78 78 - // redirects tree paths trying to access a blob; in this case the result.Files is unpopulated, 45 45 + 46 46 + // redirects tree paths trying to access a blob; in this case result.Files is unpopulated, 79 47 // so we can safely redirect to the "parent" (which is the same file). 80 48 if len(result.Files) == 0 && result.Parent == treePath { 81 81 - redirectTo := fmt.Sprintf("/%s/blob/%s/%s", ownerSlashRepo, url.PathEscape(ref), result.Parent) 49 49 + redirectTo := fmt.Sprintf("/%s/blob/%s/%s", ownerSlashRepo, url.PathEscape(displayRef), result.Parent) 82 50 http.Redirect(w, r, redirectTo, http.StatusFound) 83 51 return 84 52 } 53 53 + 85 54 user := rp.oauth.GetMultiAccountUser(r) 55 55 + 86 56 var breadcrumbs [][]string 87 87 - breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", ownerSlashRepo, url.PathEscape(ref))}) 57 57 + breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", ownerSlashRepo, url.PathEscape(displayRef))}) 88 58 if treePath != "" { 89 59 for idx, elem := range strings.Split(treePath, "/") { 90 60 breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))}) 91 61 } 92 62 } 93 93 - sortFiles(result.Files) 94 63 95 95 - // Get email to DID mapping for commit author 96 96 - var emails []string 97 97 - if xrpcResp.LastCommit != nil && xrpcResp.LastCommit.Author != nil { 98 98 - emails = append(emails, xrpcResp.LastCommit.Author.Email) 99 99 - } 100 100 - emailToDidMap, err := db.GetEmailToDid(rp.db, emails, true) 101 101 - if err != nil { 102 102 - l.Error("failed to get email to did mapping", "err", err) 103 103 - emailToDidMap = make(map[string]string) 104 104 - } 64 64 + sortFiles(result.Files) 105 65 106 106 - var lastCommitInfo *types.LastCommitInfo 107 107 - if xrpcResp.LastCommit != nil { 108 108 - when, _ := time.Parse(time.RFC3339, xrpcResp.LastCommit.When) 109 109 - lastCommitInfo = &types.LastCommitInfo{ 110 110 - Hash: plumbing.NewHash(xrpcResp.LastCommit.Hash), 111 111 - Message: xrpcResp.LastCommit.Message, 112 112 - When: when, 66 66 + var emailToDidMap map[string]string 67 67 + if lastCommit != nil && lastCommit.Author.Email != "" { 68 68 + emailToDidMap, err = db.GetEmailToDid(rp.db, []string{lastCommit.Author.Email}, true) 69 69 + if err != nil { 70 70 + l.Error("failed to get email to did mapping", "err", err) 71 71 + emailToDidMap = make(map[string]string) 113 72 } 114 114 - if xrpcResp.LastCommit.Author != nil { 115 115 - lastCommitInfo.Author.Name = xrpcResp.LastCommit.Author.Name 116 116 - lastCommitInfo.Author.Email = xrpcResp.LastCommit.Author.Email 117 117 - lastCommitInfo.Author.When, _ = time.Parse(time.RFC3339, xrpcResp.LastCommit.Author.When) 118 118 - } 73 73 + } else { 74 74 + emailToDidMap = make(map[string]string) 119 75 } 120 76 121 77 rp.pages.RepoTree(w, pages.RepoTreeParams{ ··· 124 80 Path: treePath, 125 81 RepoInfo: rp.repoResolver.GetRepoInfo(r, user), 126 82 EmailToDid: emailToDidMap, 127 127 - LastCommitInfo: lastCommitInfo, 83 83 + LastCommitInfo: lastCommit, 128 84 RepoTreeResponse: result, 129 85 }) 130 86 }

+194

appview/repo/vcsprovider.go

reviewed

··· 1 1 + package repo 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "fmt" 6 6 + "net/url" 7 7 + "time" 8 8 + 9 9 + indigoxrpc "github.com/bluesky-social/indigo/xrpc" 10 10 + "github.com/go-git/go-git/v5/plumbing" 11 11 + "tangled.org/core/api/tangled" 12 12 + "tangled.org/core/appview/models" 13 13 + xrpcclient "tangled.org/core/appview/xrpcclient" 14 14 + "tangled.org/core/types" 15 15 + ) 16 16 + 17 17 + // vcsProvider abstracts VCS-specific XRPC calls for repo handlers, 18 18 + // returning normalised types regardless of whether the repo is git or pijul. 19 19 + type vcsProvider interface { 20 20 + // GetBlob fetches file contents and returns a normalised RepoBlob_Output. 21 21 + GetBlob(ctx context.Context, ref, path string) (*tangled.RepoBlob_Output, error) 22 22 + 23 23 + // GetTree fetches a directory listing and returns a normalised RepoTreeResponse. 24 24 + // For git, the directory-level last-commit info is also returned (nil for pijul). 25 25 + GetTree(ctx context.Context, ref, path string) (types.RepoTreeResponse, *types.LastCommitInfo, error) 26 26 + 27 27 + // RawBlobXrpcPath returns the XRPC endpoint path for raw-blob proxying. 28 28 + RawBlobXrpcPath() string 29 29 + 30 30 + // SetRawBlobQuery populates query parameters for a raw-blob proxy request. 31 31 + SetRawBlobQuery(q url.Values, ref, path, repo string) 32 32 + } 33 33 + 34 34 + // newVcsProvider returns the correct vcsProvider for the given repo's VCS type. 35 35 + func newVcsProvider(repo *models.Repo, xrpcc *indigoxrpc.Client) vcsProvider { 36 36 + repoId := fmt.Sprintf("%s/%s", repo.Did, repo.Name) 37 37 + if repo.IsPijul() { 38 38 + return &pijulVcsProvider{xrpcc: xrpcc, repoId: repoId} 39 39 + } 40 40 + return &gitVcsProvider{xrpcc: xrpcc, repoId: repo.RepoIdentifier()} 41 41 + } 42 42 + 43 43 + // --- git provider --- 44 44 + 45 45 + type gitVcsProvider struct { 46 46 + xrpcc *indigoxrpc.Client 47 47 + repoId string 48 48 + } 49 49 + 50 50 + func (g *gitVcsProvider) GetBlob(ctx context.Context, ref, path string) (*tangled.RepoBlob_Output, error) { 51 51 + resp, err := tangled.RepoBlob(ctx, g.xrpcc, path, false, ref, g.repoId) 52 52 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 53 53 + return nil, xrpcerr 54 54 + } 55 55 + return resp, nil 56 56 + } 57 57 + 58 58 + func (g *gitVcsProvider) GetTree(ctx context.Context, ref, path string) (types.RepoTreeResponse, *types.LastCommitInfo, error) { 59 59 + xrpcResp, err := tangled.RepoTree(ctx, g.xrpcc, path, ref, g.repoId) 60 60 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 61 61 + return types.RepoTreeResponse{}, nil, xrpcerr 62 62 + } 63 63 + 64 64 + files := make([]types.NiceTree, len(xrpcResp.Files)) 65 65 + for i, f := range xrpcResp.Files { 66 66 + nf := types.NiceTree{ 67 67 + Name: f.Name, 68 68 + Mode: f.Mode, 69 69 + Size: int64(f.Size), 70 70 + } 71 71 + if f.Last_commit != nil { 72 72 + when, _ := time.Parse(time.RFC3339, f.Last_commit.When) 73 73 + nf.LastCommit = &types.LastCommitInfo{ 74 74 + Hash: plumbing.NewHash(f.Last_commit.Hash), 75 75 + Message: f.Last_commit.Message, 76 76 + When: when, 77 77 + } 78 78 + } 79 79 + files[i] = nf 80 80 + } 81 81 + 82 82 + result := types.RepoTreeResponse{ 83 83 + Ref: xrpcResp.Ref, 84 84 + Files: files, 85 85 + } 86 86 + if xrpcResp.Parent != nil { 87 87 + result.Parent = *xrpcResp.Parent 88 88 + } 89 89 + if xrpcResp.Dotdot != nil { 90 90 + result.DotDot = *xrpcResp.Dotdot 91 91 + } 92 92 + if xrpcResp.Readme != nil { 93 93 + result.ReadmeFileName = xrpcResp.Readme.Filename 94 94 + result.Readme = xrpcResp.Readme.Contents 95 95 + } 96 96 + 97 97 + var lastCommit *types.LastCommitInfo 98 98 + if xrpcResp.LastCommit != nil { 99 99 + when, _ := time.Parse(time.RFC3339, xrpcResp.LastCommit.When) 100 100 + lastCommit = &types.LastCommitInfo{ 101 101 + Hash: plumbing.NewHash(xrpcResp.LastCommit.Hash), 102 102 + Message: xrpcResp.LastCommit.Message, 103 103 + When: when, 104 104 + } 105 105 + if xrpcResp.LastCommit.Author != nil { 106 106 + lastCommit.Author.Name = xrpcResp.LastCommit.Author.Name 107 107 + lastCommit.Author.Email = xrpcResp.LastCommit.Author.Email 108 108 + lastCommit.Author.When, _ = time.Parse(time.RFC3339, xrpcResp.LastCommit.Author.When) 109 109 + } 110 110 + } 111 111 + 112 112 + return result, lastCommit, nil 113 113 + } 114 114 + 115 115 + func (g *gitVcsProvider) RawBlobXrpcPath() string { 116 116 + return "/xrpc/sh.tangled.repo.blob" 117 117 + } 118 118 + 119 119 + func (g *gitVcsProvider) SetRawBlobQuery(q url.Values, ref, path, repo string) { 120 120 + q.Set("repo", repo) 121 121 + q.Set("ref", ref) 122 122 + q.Set("path", path) 123 123 + q.Set("raw", "true") 124 124 + } 125 125 + 126 126 + // --- pijul provider --- 127 127 + 128 128 + type pijulVcsProvider struct { 129 129 + xrpcc *indigoxrpc.Client 130 130 + repoId string 131 131 + } 132 132 + 133 133 + func (p *pijulVcsProvider) GetBlob(ctx context.Context, ref, path string) (*tangled.RepoBlob_Output, error) { 134 134 + pResp, err := tangled.RepoPijulBlob(ctx, p.xrpcc, ref, path, p.repoId) 135 135 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 136 136 + return nil, xrpcerr 137 137 + } 138 138 + return &tangled.RepoBlob_Output{ 139 139 + Path: pResp.Path, 140 140 + Content: pResp.Contents, 141 141 + IsBinary: &pResp.Is_binary, 142 142 + }, nil 143 143 + } 144 144 + 145 145 + func (p *pijulVcsProvider) GetTree(ctx context.Context, ref, path string) (types.RepoTreeResponse, *types.LastCommitInfo, error) { 146 146 + xrpcResp, err := tangled.RepoPijulTree(ctx, p.xrpcc, ref, path, p.repoId) 147 147 + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 148 148 + return types.RepoTreeResponse{}, nil, xrpcerr 149 149 + } 150 150 + 151 151 + files := make([]types.NiceTree, len(xrpcResp.Files)) 152 152 + for i, f := range xrpcResp.Files { 153 153 + files[i] = types.NiceTree{ 154 154 + Name: f.Name, 155 155 + Mode: f.Mode, 156 156 + Size: f.Size, 157 157 + } 158 158 + } 159 159 + 160 160 + result := types.RepoTreeResponse{ 161 161 + Ref: ref, 162 162 + Files: files, 163 163 + } 164 164 + if xrpcResp.Ref != nil { 165 165 + result.Ref = *xrpcResp.Ref 166 166 + } 167 167 + if xrpcResp.Parent != nil { 168 168 + result.Parent = *xrpcResp.Parent 169 169 + } 170 170 + if xrpcResp.Dotdot != nil { 171 171 + result.DotDot = *xrpcResp.Dotdot 172 172 + } 173 173 + if xrpcResp.Readme != nil { 174 174 + if xrpcResp.Readme.Filename != nil { 175 175 + result.ReadmeFileName = *xrpcResp.Readme.Filename 176 176 + } 177 177 + if xrpcResp.Readme.Contents != nil { 178 178 + result.Readme = *xrpcResp.Readme.Contents 179 179 + } 180 180 + } 181 181 + 182 182 + return result, nil, nil // pijul has no directory-level last-commit info 183 183 + } 184 184 + 185 185 + func (p *pijulVcsProvider) RawBlobXrpcPath() string { 186 186 + return "/xrpc/sh.tangled.repo.pijulBlob" 187 187 + } 188 188 + 189 189 + func (p *pijulVcsProvider) SetRawBlobQuery(q url.Values, ref, path, repo string) { 190 190 + q.Set("repo", repo) 191 191 + q.Set("channel", ref) 192 192 + q.Set("path", path) 193 193 + // pijul does not use raw=true 194 194 + }

+1

appview/reporesolver/resolver.go

reviewed

··· 128 128 Topics: repo.Topics, 129 129 Knot: repo.Knot, 130 130 Spindle: repo.Spindle, 131 131 + Vcs: repo.Vcs, 131 132 Stats: *stats, 132 133 133 134 // fork repo upstream

+36

appview/state/knotstream.go

reviewed

··· 87 87 switch msg.Nsid { 88 88 case tangled.GitRefUpdateNSID: 89 89 return ingestRefUpdate(ctx, d, enforcer, posthog, notifier, dev, c, cfClient, source, msg) 90 90 + case tangled.PijulRefUpdateNSID: 91 91 + return ingestPijulRefUpdate(d, source, msg) 90 92 case tangled.PipelineNSID: 91 93 return ingestPipeline(d, source, msg) 92 94 case knotdb.RepoDIDAssignNSID: ··· 303 305 } 304 306 305 307 return tx.Commit() 308 308 + } 309 309 + 310 310 + func ingestPijulRefUpdate(d *db.DB, source ec.Source, msg ec.Message) error { 311 311 + var record tangled.PijulRefUpdate 312 312 + if err := json.Unmarshal(msg.EventJson, &record); err != nil { 313 313 + return fmt.Errorf("unmarshal pijulRefUpdate: %w", err) 314 314 + } 315 315 + 316 316 + if record.CommitterDid == "" || len(record.Changes) == 0 { 317 317 + return nil 318 318 + } 319 319 + 320 320 + // Parse the AT URI to find the repo. 321 321 + repoAtURI, err := syntax.ParseATURI(record.Repo) 322 322 + if err != nil { 323 323 + return fmt.Errorf("invalid repo AT URI %q: %w", record.Repo, err) 324 324 + } 325 325 + 326 326 + repoDid := repoAtURI.Authority().String() 327 327 + repo, err := db.GetRepoByDid(d, repoDid) 328 328 + if err != nil { 329 329 + // Repo may be unknown to this appview; skip silently. 330 330 + return nil 331 331 + } 332 332 + 333 333 + if repo.Knot != source.Key() { 334 334 + return fmt.Errorf("pijulRefUpdate from %s for repo on %s, rejecting", source.Key(), repo.Knot) 335 335 + } 336 336 + 337 337 + return db.AddPunch(d, models.Punch{ 338 338 + Did: record.CommitterDid, 339 339 + Date: time.Now(), 340 340 + Count: len(record.Changes), 341 341 + }) 306 342 } 307 343 308 344 func ingestPipeline(d *db.DB, source ec.Source, msg ec.Message) error {

+19

appview/state/router.go

reviewed

··· 8 8 9 9 "github.com/go-chi/chi/v5" 10 10 "tangled.org/core/appview/db" 11 11 + "tangled.org/core/appview/discussions" 11 12 "tangled.org/core/appview/issues" 12 13 "tangled.org/core/appview/knots" 13 14 "tangled.org/core/appview/labels" ··· 117 118 r.With(mw.ResolveRepo()).Route("/{repo}", func(r chi.Router) { 118 119 r.Use(mw.GoImport()) 119 120 r.Mount("/", s.RepoRouter(mw)) 121 121 + r.Mount("/discussions", s.DiscussionsRouter(mw)) 120 122 r.Mount("/issues", s.IssuesRouter(mw)) 121 123 r.Mount("/pulls", s.PullsRouter(mw)) 122 124 r.Mount("/pipelines", s.PipelinesRouter(mw)) ··· 310 312 log.SubLogger(s.logger, "issues"), 311 313 ) 312 314 return issues.Router(mw) 315 315 + } 316 316 + 317 317 + func (s *State) DiscussionsRouter(mw *middleware.Middleware) http.Handler { 318 318 + discussions := discussions.New( 319 319 + s.oauth, 320 320 + s.repoResolver, 321 321 + s.enforcer, 322 322 + s.pages, 323 323 + s.idResolver, 324 324 + s.mentionsResolver, 325 325 + s.db, 326 326 + s.config, 327 327 + s.notifier, 328 328 + s.validator, 329 329 + log.SubLogger(s.logger, "discussions"), 330 330 + ) 331 331 + return discussions.Router(mw) 313 332 } 314 333 315 334 func (s *State) PullsRouter(mw *middleware.Middleware) http.Handler {

+14 -1

appview/state/state.go

reviewed

··· 432 432 } 433 433 l = l.With("defaultBranch", defaultBranch) 434 434 435 435 + vcs := strings.ToLower(strings.TrimSpace(r.FormValue("vcs"))) 436 436 + if vcs == "" { 437 437 + vcs = "git" 438 438 + } 439 439 + switch vcs { 440 440 + case "git", "pijul": 441 441 + default: 442 442 + s.pages.Notice(w, "repo", "Invalid repository type.") 443 443 + return 444 444 + } 445 445 + l = l.With("vcs", vcs) 446 446 + 435 447 description := r.FormValue("description") 436 448 if len([]rune(description)) > 140 { 437 449 s.pages.Notice(w, "repo", "Description must be 140 characters or fewer.") ··· 476 488 Rkey: rkey, 477 489 Name: repoName, 478 490 DefaultBranch: &defaultBranch, 491 491 + Vcs: &vcs, 479 492 } 480 493 createResp, xe := tangled.RepoCreate( 481 494 r.Context(), ··· 507 520 Created: time.Now(), 508 521 Labels: s.config.Label.DefaultLabelDefs, 509 522 RepoDid: repoDid, 523 523 + Vcs: vcs, 510 524 } 511 525 record := repo.AsRecord() 512 526 ··· 611 625 s.pages.Notice(w, "repo", "Failed to set up repository permissions.") 612 626 return 613 627 } 614 614 - 615 628 err = tx.Commit() 616 629 if err != nil { 617 630 l.Error("txn commit failed", "err", err)

+4

cmd/cborgen/cborgen.go

reviewed

··· 30 30 tangled.LabelDefinition_ValueType{}, 31 31 tangled.LabelOp{}, 32 32 tangled.LabelOp_Operand{}, 33 33 + tangled.PijulRefUpdate{}, 33 34 tangled.Pipeline{}, 34 35 tangled.Pipeline_CloneOpts{}, 35 36 tangled.Pipeline_ManualTriggerData{}, ··· 44 45 tangled.Repo{}, 45 46 tangled.RepoArtifact{}, 46 47 tangled.RepoCollaborator{}, 48 48 + tangled.RepoDiscussion{}, 49 49 + tangled.RepoDiscussionComment{}, 50 50 + tangled.RepoDiscussionState{}, 47 51 tangled.RepoIssue{}, 48 52 tangled.RepoIssueComment{}, 49 53 tangled.RepoIssueState{},

-1

flake.nix

reviewed

··· 331 331 332 332 rm -f api/tangled/* 333 333 lexgen --build-file lexicon-build-config.json lexicons 334 334 - sed -i.bak 's/\tutil/\/\/\tutil/' api/tangled/* 335 334 # lexgen generates incomplete Marshaler/Unmarshaler for union types 336 335 find api/tangled/*.go -not -name "cbor_gen.go" -exec \ 337 336 sed -i '/^func.*\(MarshalCBOR\|UnmarshalCBOR\)/,/^}/ s/^/\/\/ /' {} +

+105

guard/guard.go

reviewed

··· 1 1 package guard 2 2 3 3 import ( 4 4 + "bufio" 4 5 "context" 5 6 "errors" 6 7 "fmt" ··· 105 106 os.Exit(-1) 106 107 } 107 108 109 109 + if cmdParts[0] == "pijul" { 110 110 + if cmdParts[1] != "protocol" { 111 111 + l.Error("access denied: invalid pijul command", "command", sshCommand) 112 112 + fmt.Fprintln(os.Stderr, "access denied: invalid pijul command") 113 113 + return fmt.Errorf("access denied: invalid pijul command") 114 114 + } 115 115 + 116 116 + repoPath, version, _ := parsePijulProtocolArgs(cmdParts[2:]) 117 117 + if version != "" && version != "3" { 118 118 + l.Error("unsupported pijul protocol version", "version", version) 119 119 + fmt.Fprintln(os.Stderr, "unsupported pijul protocol version") 120 120 + return fmt.Errorf("unsupported pijul protocol version") 121 121 + } 122 122 + 123 123 + // If no repository is specified, this is a prove-only session. 124 124 + // (pijul identity prove connects without a repository path) 125 125 + if repoPath == "" { 126 126 + l.Info("pijul prove session (no repo)", 127 127 + "user", incomingUser, 128 128 + "client", clientIP) 129 129 + 130 130 + stdinReader := bufio.NewReader(os.Stdin) 131 131 + if err := handlePijulProve(l, endpoint, incomingUser, stdinReader); err != nil { 132 132 + l.Error("prove failed", "error", err) 133 133 + fmt.Fprintf(os.Stderr, "prove failed: %v\n", err) 134 134 + return fmt.Errorf("prove failed: %v", err) 135 135 + } 136 136 + 137 137 + l.Info("prove completed", 138 138 + "user", incomingUser, 139 139 + "success", true) 140 140 + return nil 141 141 + } 142 142 + 143 143 + qualifiedRepoPath, err := guardAndQualifyRepo(l, endpoint, incomingUser, repoPath, "pijul-protocol") 144 144 + if err != nil { 145 145 + l.Error("failed to run guard", "err", err) 146 146 + fmt.Fprintln(os.Stderr, err) 147 147 + os.Exit(1) 148 148 + } 149 149 + 150 150 + fullPath, _ := securejoin.SecureJoin(gitDir, qualifiedRepoPath) 151 151 + args := []string{"protocol", "--repository", fullPath} 152 152 + if version != "" { 153 153 + args = append(args, "--version", version) 154 154 + } 155 155 + 156 156 + l.Info("processing command", 157 157 + "user", incomingUser, 158 158 + "command", "pijul protocol", 159 159 + "repo", repoPath, 160 160 + "fullPath", fullPath, 161 161 + "client", clientIP) 162 162 + 163 163 + pijulCmd := exec.Command("pijul", args...) 164 164 + pijulCmd.Stdout = os.Stdout 165 165 + pijulCmd.Stderr = os.Stderr 166 166 + pijulCmd.Stdin = os.Stdin 167 167 + 168 168 + if err := pijulCmd.Run(); err != nil { 169 169 + l.Error("command failed", "error", err) 170 170 + fmt.Fprintf(os.Stderr, "command failed: %v\n", err) 171 171 + return fmt.Errorf("command failed: %v", err) 172 172 + } 173 173 + 174 174 + l.Info("command completed", 175 175 + "user", incomingUser, 176 176 + "command", "pijul protocol", 177 177 + "repo", repoPath, 178 178 + "success", true) 179 179 + 180 180 + return nil 181 181 + } 182 182 + 108 183 gitCommand := cmdParts[0] 109 184 repoPath := cmdParts[1] 110 185 ··· 171 246 "success", true) 172 247 173 248 return nil 249 249 + } 250 250 + 251 251 + func parsePijulProtocolArgs(args []string) (string, string, error) { 252 252 + var repo string 253 253 + var version string 254 254 + for i := 0; i < len(args); i++ { 255 255 + arg := args[i] 256 256 + switch { 257 257 + case arg == "--repository" || arg == "-r": 258 258 + if i+1 >= len(args) { 259 259 + return "", "", fmt.Errorf("missing --repository value") 260 260 + } 261 261 + repo = args[i+1] 262 262 + i++ 263 263 + case strings.HasPrefix(arg, "--repository="): 264 264 + repo = strings.TrimPrefix(arg, "--repository=") 265 265 + case arg == "--version": 266 266 + if i+1 >= len(args) { 267 267 + return "", "", fmt.Errorf("missing --version value") 268 268 + } 269 269 + version = args[i+1] 270 270 + i++ 271 271 + case strings.HasPrefix(arg, "--version="): 272 272 + version = strings.TrimPrefix(arg, "--version=") 273 273 + } 274 274 + } 275 275 + if repo == "" { 276 276 + return "", "", fmt.Errorf("missing --repository") 277 277 + } 278 278 + return repo, version, nil 174 279 } 175 280 176 281 // runs guardAndQualifyRepo logic

+174

guard/prove.go

reviewed

··· 1 1 + package guard 2 2 + 3 3 + import ( 4 4 + "bufio" 5 5 + "bytes" 6 6 + "crypto/ed25519" 7 7 + "crypto/rand" 8 8 + "encoding/json" 9 9 + "fmt" 10 10 + "io" 11 11 + "log/slog" 12 12 + "math/big" 13 13 + "net/http" 14 14 + "os" 15 15 + "strings" 16 16 + ) 17 17 + 18 18 + // pijulPublicKey matches the JSON format sent by pijul's prove protocol. 19 19 + // Example: {"version":1,"algorithm":"Ed25519","key":"<base58>","signature":"<base58>"} 20 20 + type pijulPublicKey struct { 21 21 + Version int `json:"version"` 22 22 + Algorithm string `json:"algorithm"` 23 23 + Key string `json:"key"` 24 24 + Signature string `json:"signature"` 25 25 + Expires string `json:"expires,omitempty"` 26 26 + } 27 27 + 28 28 + // handlePijulProve handles the pijul identity prove protocol over stdin/stdout. 29 29 + // Protocol: 30 30 + // 1. Client sends: challenge <json_public_key>\n 31 31 + // 2. Server sends: <random_challenge>\n 32 32 + // 3. Client sends: prove <base58_signature>\n 33 33 + // 4. Server sends: \n (success) 34 34 + func handlePijulProve(l *slog.Logger, endpoint string, did string, reader *bufio.Reader) error { 35 35 + // Read the challenge request 36 36 + line, err := reader.ReadString('\n') 37 37 + if err != nil { 38 38 + return fmt.Errorf("failed to read from stdin: %w", err) 39 39 + } 40 40 + line = strings.TrimRight(line, "\n\r") 41 41 + 42 42 + if !strings.HasPrefix(line, "challenge ") { 43 43 + return fmt.Errorf("expected 'challenge' message, got: %q", line) 44 44 + } 45 45 + 46 46 + pubKeyJSON := strings.TrimPrefix(line, "challenge ") 47 47 + 48 48 + var pubKey pijulPublicKey 49 49 + if err := json.Unmarshal([]byte(pubKeyJSON), &pubKey); err != nil { 50 50 + return fmt.Errorf("failed to parse public key JSON: %w", err) 51 51 + } 52 52 + 53 53 + if pubKey.Algorithm != "Ed25519" { 54 54 + return fmt.Errorf("unsupported algorithm: %s", pubKey.Algorithm) 55 55 + } 56 56 + 57 57 + // Decode the base58 public key 58 58 + rawPubKey, err := base58Decode(pubKey.Key) 59 59 + if err != nil { 60 60 + return fmt.Errorf("failed to decode public key: %w", err) 61 61 + } 62 62 + if len(rawPubKey) != ed25519.PublicKeySize { 63 63 + return fmt.Errorf("invalid public key size: %d", len(rawPubKey)) 64 64 + } 65 65 + 66 66 + // Generate random challenge (30 alphanumeric characters, matching Nest) 67 67 + challenge := generateChallenge(30) 68 68 + 69 69 + l.Info("prove: sending challenge", "did", did, "pubkey", pubKey.Key) 70 70 + 71 71 + // Send the challenge 72 72 + fmt.Fprintf(os.Stdout, "%s\n", challenge) 73 73 + 74 74 + // Read the prove response 75 75 + line, err = reader.ReadString('\n') 76 76 + if err != nil { 77 77 + return fmt.Errorf("failed to read prove response: %w", err) 78 78 + } 79 79 + line = strings.TrimRight(line, "\n\r") 80 80 + 81 81 + if !strings.HasPrefix(line, "prove ") { 82 82 + return fmt.Errorf("expected 'prove' message, got: %q", line) 83 83 + } 84 84 + 85 85 + signatureB58 := strings.TrimPrefix(line, "prove ") 86 86 + 87 87 + // Decode the base58 signature 88 88 + signature, err := base58Decode(signatureB58) 89 89 + if err != nil { 90 90 + return fmt.Errorf("failed to decode signature: %w", err) 91 91 + } 92 92 + 93 93 + // Verify the Ed25519 signature 94 94 + if !ed25519.Verify(ed25519.PublicKey(rawPubKey), []byte(challenge), signature) { 95 95 + l.Warn("prove: signature verification failed", "did", did) 96 96 + fmt.Fprintf(os.Stderr, "Signature verification failed\n") 97 97 + return fmt.Errorf("signature verification failed") 98 98 + } 99 99 + 100 100 + l.Info("prove: signature verified", "did", did, "pubkey", pubKey.Key) 101 101 + 102 102 + // Store the pubkey → DID mapping via knotserver internal API 103 103 + if err := storePijulProve(endpoint, pubKey.Key, did); err != nil { 104 104 + l.Error("prove: failed to store mapping", "err", err) 105 105 + return fmt.Errorf("failed to store prove result: %w", err) 106 106 + } 107 107 + 108 108 + // Send success (empty line) 109 109 + fmt.Fprintf(os.Stdout, "\n") 110 110 + 111 111 + l.Info("prove: completed successfully", "did", did, "pubkey", pubKey.Key) 112 112 + return nil 113 113 + } 114 114 + 115 115 + func storePijulProve(endpoint, publicKey, did string) error { 116 116 + body, _ := json.Marshal(map[string]string{ 117 117 + "public_key": publicKey, 118 118 + "did": did, 119 119 + }) 120 120 + 121 121 + resp, err := http.Post(endpoint+"/pijul-prove", "application/json", bytes.NewReader(body)) 122 122 + if err != nil { 123 123 + return err 124 124 + } 125 125 + defer resp.Body.Close() 126 126 + 127 127 + if resp.StatusCode != http.StatusOK { 128 128 + respBody, _ := io.ReadAll(resp.Body) 129 129 + return fmt.Errorf("knotserver returned %d: %s", resp.StatusCode, string(respBody)) 130 130 + } 131 131 + return nil 132 132 + } 133 133 + 134 134 + func generateChallenge(length int) string { 135 135 + const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" 136 136 + b := make([]byte, length) 137 137 + for i := range b { 138 138 + n, _ := rand.Int(rand.Reader, big.NewInt(int64(len(charset)))) 139 139 + b[i] = charset[n.Int64()] 140 140 + } 141 141 + return string(b) 142 142 + } 143 143 + 144 144 + // base58Decode decodes a base58-encoded string (Bitcoin alphabet). 145 145 + func base58Decode(input string) ([]byte, error) { 146 146 + const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" 147 147 + 148 148 + result := big.NewInt(0) 149 149 + base := big.NewInt(58) 150 150 + 151 151 + for _, c := range input { 152 152 + idx := strings.IndexRune(alphabet, c) 153 153 + if idx < 0 { 154 154 + return nil, fmt.Errorf("invalid base58 character: %c", c) 155 155 + } 156 156 + result.Mul(result, base) 157 157 + result.Add(result, big.NewInt(int64(idx))) 158 158 + } 159 159 + 160 160 + // Count leading '1's (zero bytes) 161 161 + leadingZeros := 0 162 162 + for _, c := range input { 163 163 + if c != '1' { 164 164 + break 165 165 + } 166 166 + leadingZeros++ 167 167 + } 168 168 + 169 169 + resultBytes := result.Bytes() 170 170 + decoded := make([]byte, leadingZeros+len(resultBytes)) 171 171 + copy(decoded[leadingZeros:], resultBytes) 172 172 + 173 173 + return decoded, nil 174 174 + }

+4 -1

knotserver/config/config.go

reviewed

··· 3 3 import ( 4 4 "context" 5 5 "fmt" 6 6 + "strings" 6 7 7 8 "github.com/bluesky-social/indigo/atproto/syntax" 8 9 "github.com/sethvargo/go-envconfig" ··· 35 36 } 36 37 37 38 func (s Server) Did() syntax.DID { 38 38 - return syntax.DID(fmt.Sprintf("did:web:%s", s.Hostname)) 39 39 + // did:web spec requires colons to be encoded as %3A 40 40 + encoded := strings.ReplaceAll(s.Hostname, ":", "%3A") 41 41 + return syntax.DID(fmt.Sprintf("did:web:%s", encoded)) 39 42 } 40 43 41 44 type Config struct {

+7

knotserver/db/db.go

reviewed

··· 80 80 id integer primary key autoincrement, 81 81 name text unique 82 82 ); 83 83 + 84 84 + create table if not exists pijul_signing_keys ( 85 85 + public_key text primary key, 86 86 + did text not null, 87 87 + created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 88 88 + foreign key (did) references known_dids(did) on delete cascade 89 89 + ); 83 90 `) 84 91 if err != nil { 85 92 return nil, err

+54

knotserver/db/pijulkeys.go

reviewed

··· 1 1 + package db 2 2 + 3 3 + import "strings" 4 4 + 5 5 + // StorePijulSigningKey stores a verified pijul public key → DID mapping. 6 6 + func (d *DB) StorePijulSigningKey(publicKey, did string) error { 7 7 + _, err := d.db.Exec(` 8 8 + insert or replace into pijul_signing_keys (public_key, did) 9 9 + values (?, ?) 10 10 + `, publicKey, did) 11 11 + return err 12 12 + } 13 13 + 14 14 + // GetDidForPijulKey returns the DID associated with a pijul public key. 15 15 + func (d *DB) GetDidForPijulKey(publicKey string) (string, error) { 16 16 + var did string 17 17 + err := d.db.QueryRow(` 18 18 + select did from pijul_signing_keys where public_key = ? 19 19 + `, publicKey).Scan(&did) 20 20 + return did, err 21 21 + } 22 22 + 23 23 + // GetPijulKeyToDid returns a map of pijul public key → DID for the given keys. 24 24 + func (d *DB) GetPijulKeyToDid(keys []string) (map[string]string, error) { 25 25 + if len(keys) == 0 { 26 26 + return make(map[string]string), nil 27 27 + } 28 28 + 29 29 + placeholders := make([]string, len(keys)) 30 30 + args := make([]any, len(keys)) 31 31 + for i, k := range keys { 32 32 + placeholders[i] = "?" 33 33 + args[i] = k 34 34 + } 35 35 + 36 36 + rows, err := d.db.Query(` 37 37 + select public_key, did from pijul_signing_keys 38 38 + where public_key in (`+strings.Join(placeholders, ",")+`) 39 39 + `, args...) 40 40 + if err != nil { 41 41 + return nil, err 42 42 + } 43 43 + defer rows.Close() 44 44 + 45 45 + result := make(map[string]string) 46 46 + for rows.Next() { 47 47 + var key, did string 48 48 + if err := rows.Scan(&key, &did); err != nil { 49 49 + return nil, err 50 50 + } 51 51 + result[key] = did 52 52 + } 53 53 + return result, rows.Err() 54 54 + }

+5

knotserver/git/git.go

reviewed

··· 80 80 return g.h 81 81 } 82 82 83 83 + // Path returns the on-disk path of the repository. 84 84 + func (g *GitRepo) Path() string { 85 85 + return g.path 86 86 + } 87 87 + 83 88 // re-open a repository and update references 84 89 func (g *GitRepo) Refresh() error { 85 90 refreshed, err := PlainOpen(g.path)

+1

knotserver/ingester.go

reviewed

··· 17 17 "tangled.org/core/api/tangled" 18 18 "tangled.org/core/knotserver/db" 19 19 "tangled.org/core/knotserver/git" 20 20 + 20 21 "tangled.org/core/log" 21 22 "tangled.org/core/rbac" 22 23 "tangled.org/core/workflow"

+46 -1

knotserver/internal.go

reviewed

··· 87 87 return 88 88 } 89 89 90 90 - components := strings.Split(strings.TrimPrefix(strings.Trim(repo, "'"), "/"), "/") 90 90 + // did:foo/repo-name or 91 91 + // handle/repo-name or 92 92 + // any of the above with a leading slash (/) 93 93 + components := strings.Split(strings.TrimPrefix(strings.Trim(repo, "'\""), "/"), "/") 91 94 l.Info("command components", "components", components) 92 95 93 96 var rbacResource string ··· 170 173 } 171 174 172 175 if gitCommand == "git-receive-pack" { 176 176 + ok, err := h.e.IsPushAllowed(incomingUser, rbac.ThisServer, rbacResource) 177 177 + if err != nil || !ok { 178 178 + w.WriteHeader(http.StatusForbidden) 179 179 + fmt.Fprint(w, repo) 180 180 + return 181 181 + } 182 182 + } 183 183 + if gitCommand == "pijul-protocol" { 173 184 ok, err := h.e.IsPushAllowed(incomingUser, rbac.ThisServer, rbacResource) 174 185 if err != nil || !ok { 175 186 w.WriteHeader(http.StatusForbidden) ··· 476 487 return nil 477 488 } 478 489 490 490 + // PijulProve stores a verified pijul public key → DID mapping. 491 491 + // Called by the guard after a successful prove challenge-response. 492 492 + func (h *InternalHandle) PijulProve(w http.ResponseWriter, r *http.Request) { 493 493 + l := h.l.With("handler", "PijulProve") 494 494 + 495 495 + var req struct { 496 496 + PublicKey string `json:"public_key"` 497 497 + Did string `json:"did"` 498 498 + } 499 499 + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { 500 500 + l.Error("failed to decode request", "err", err) 501 501 + w.WriteHeader(http.StatusBadRequest) 502 502 + fmt.Fprintln(w, "invalid request body") 503 503 + return 504 504 + } 505 505 + 506 506 + if req.PublicKey == "" || req.Did == "" { 507 507 + w.WriteHeader(http.StatusBadRequest) 508 508 + fmt.Fprintln(w, "missing public_key or did") 509 509 + return 510 510 + } 511 511 + 512 512 + if err := h.db.StorePijulSigningKey(req.PublicKey, req.Did); err != nil { 513 513 + l.Error("failed to store pijul signing key", "err", err, "did", req.Did) 514 514 + w.WriteHeader(http.StatusInternalServerError) 515 515 + fmt.Fprintln(w, "failed to store signing key") 516 516 + return 517 517 + } 518 518 + 519 519 + l.Info("stored pijul signing key", "did", req.Did, "public_key", req.PublicKey) 520 520 + w.WriteHeader(http.StatusOK) 521 521 + } 522 522 + 479 523 func Internal(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer, n *notifier.Notifier) http.Handler { 480 524 r := chi.NewRouter() 481 525 l := log.FromContext(ctx) ··· 495 539 r.Get("/keys", h.InternalKeys) 496 540 r.Get("/guard", h.Guard) 497 541 r.Post("/hooks/post-receive", h.PostReceiveHook) 542 542 + r.Post("/pijul-prove", h.PijulProve) 498 543 r.Mount("/debug", middleware.Profiler()) 499 544 500 545 return r

+518

knotserver/pijul/change.go

reviewed

··· 1 1 + package pijul 2 2 + 3 3 + import ( 4 4 + "bufio" 5 5 + "bytes" 6 6 + "encoding/json" 7 7 + "fmt" 8 8 + "log/slog" 9 9 + "strconv" 10 10 + "strings" 11 11 + "time" 12 12 + ) 13 13 + 14 14 + // Change represents a Pijul change (analogous to a Git commit) 15 15 + type Change struct { 16 16 + // Hash is the unique identifier for this change (base32 encoded) 17 17 + Hash string `json:"hash"` 18 18 + 19 19 + // Authors who created this change 20 20 + Authors []Author `json:"authors"` 21 21 + 22 22 + // Message is the change description 23 23 + Message string `json:"message"` 24 24 + 25 25 + // Timestamp when the change was recorded 26 26 + Timestamp time.Time `json:"timestamp"` 27 27 + 28 28 + // Dependencies are hashes of changes this change depends on 29 29 + Dependencies []string `json:"dependencies,omitempty"` 30 30 + 31 31 + // Channel where this change exists 32 32 + Channel string `json:"channel,omitempty"` 33 33 + 34 34 + // State is the Pijul Merkle state hash of the channel after this change 35 35 + // was applied. Populated when running pijul log --state. 36 36 + State string `json:"state,omitempty"` 37 37 + } 38 38 + 39 39 + // Author represents a change author 40 40 + type Author struct { 41 41 + Name string `json:"name"` 42 42 + Email string `json:"email,omitempty"` 43 43 + // DID is the AT Protocol decentralized identifier of the author. 44 44 + // Populated from the change's unhashed identity section when present. 45 45 + DID string `json:"did,omitempty"` 46 46 + } 47 47 + 48 48 + // Changes returns a list of changes in the repository 49 49 + // offset and limit control pagination 50 50 + func (p *PijulRepo) Changes(offset, limit int) ([]Change, error) { 51 51 + args := []string{"--offset", strconv.Itoa(offset), "--limit", strconv.Itoa(limit)} 52 52 + 53 53 + if p.channelName != "" { 54 54 + args = append(args, "--channel", p.channelName) 55 55 + } 56 56 + 57 57 + output, err := p.log(args...) 58 58 + if err != nil { 59 59 + if isNoChangesError(err) { 60 60 + return []Change{}, nil 61 61 + } 62 62 + return nil, fmt.Errorf("pijul log: %w", err) 63 63 + } 64 64 + 65 65 + return parseLogOutput(output) 66 66 + } 67 67 + 68 68 + // TotalChanges returns the total number of changes in the current channel 69 69 + func (p *PijulRepo) TotalChanges() (int, error) { 70 70 + // pijul log doesn't have a --count option, so we need to count 71 71 + // We can use pijul log with a large limit or iterate 72 72 + args := []string{"--hash-only"} 73 73 + 74 74 + if p.channelName != "" { 75 75 + args = append(args, "--channel", p.channelName) 76 76 + } 77 77 + 78 78 + output, err := p.log(args...) 79 79 + if err != nil { 80 80 + if isNoChangesError(err) { 81 81 + return 0, nil 82 82 + } 83 83 + return 0, fmt.Errorf("pijul log: %w", err) 84 84 + } 85 85 + 86 86 + // Count lines (each line is a change hash) 87 87 + lines := strings.Split(strings.TrimSpace(string(output)), "\n") 88 88 + if len(lines) == 1 && lines[0] == "" { 89 89 + return 0, nil 90 90 + } 91 91 + 92 92 + return len(lines), nil 93 93 + } 94 94 + 95 95 + func isNoChangesError(err error) bool { 96 96 + if err == nil { 97 97 + return false 98 98 + } 99 99 + lower := strings.ToLower(err.Error()) 100 100 + return strings.Contains(lower, "no changes") || strings.Contains(lower, "no change") 101 101 + } 102 102 + 103 103 + // GetChange retrieves details for a specific change by hash 104 104 + func (p *PijulRepo) GetChange(hash string) (*Change, error) { 105 105 + // Use pijul change to get change details 106 106 + output, err := p.change(hash) 107 107 + if err != nil { 108 108 + return nil, fmt.Errorf("pijul change %s: %w", hash, err) 109 109 + } 110 110 + 111 111 + return parseChangeOutput(hash, output) 112 112 + } 113 113 + 114 114 + // parseLogOutput parses the output of pijul log 115 115 + // Expected format (default output): 116 116 + // 117 117 + // Hash: XXXXX 118 118 + // Author: Name <email> 119 119 + // Date: 2024-01-01 12:00:00 120 120 + // 121 121 + // Message line 1 122 122 + // Message line 2 123 123 + func parseLogOutput(output []byte) ([]Change, error) { 124 124 + var changes []Change 125 125 + scanner := bufio.NewScanner(bytes.NewReader(output)) 126 126 + 127 127 + var current *Change 128 128 + var messageLines []string 129 129 + inMessage := false 130 130 + 131 131 + for scanner.Scan() { 132 132 + line := scanner.Text() 133 133 + 134 134 + if strings.HasPrefix(line, "Hash: ") || strings.HasPrefix(line, "Change ") { 135 135 + // Save previous change if exists 136 136 + if current != nil { 137 137 + current.Message = strings.TrimSpace(strings.Join(messageLines, "\n")) 138 138 + changes = append(changes, *current) 139 139 + } 140 140 + 141 141 + hashLine := line 142 142 + if strings.HasPrefix(hashLine, "Change ") { 143 143 + hashLine = strings.Replace(hashLine, "Change ", "Hash: ", 1) 144 144 + } 145 145 + current = &Change{ 146 146 + Hash: strings.TrimPrefix(hashLine, "Hash: "), 147 147 + } 148 148 + messageLines = nil 149 149 + inMessage = false 150 150 + continue 151 151 + } 152 152 + 153 153 + if current == nil { 154 154 + continue 155 155 + } 156 156 + 157 157 + if strings.HasPrefix(line, "Author: ") { 158 158 + authorStr := strings.TrimPrefix(line, "Author: ") 159 159 + author := parseAuthor(authorStr) 160 160 + current.Authors = append(current.Authors, author) 161 161 + continue 162 162 + } 163 163 + 164 164 + if strings.HasPrefix(line, "State: ") { 165 165 + current.State = strings.TrimPrefix(line, "State: ") 166 166 + continue 167 167 + } 168 168 + 169 169 + if strings.HasPrefix(line, "Date: ") { 170 170 + dateStr := strings.TrimPrefix(line, "Date: ") 171 171 + if t, err := parseTimestamp(dateStr); err == nil { 172 172 + current.Timestamp = t 173 173 + } else { 174 174 + slog.Warn("failed to parse pijul log timestamp", "value", dateStr, "error", err) 175 175 + } 176 176 + continue 177 177 + } 178 178 + 179 179 + // Empty line before message 180 180 + if line == "" && !inMessage { 181 181 + inMessage = true 182 182 + continue 183 183 + } 184 184 + 185 185 + if inMessage { 186 186 + messageLines = append(messageLines, strings.TrimPrefix(line, " ")) 187 187 + } 188 188 + } 189 189 + 190 190 + // Don't forget the last change 191 191 + if current != nil { 192 192 + current.Message = strings.TrimSpace(strings.Join(messageLines, "\n")) 193 193 + changes = append(changes, *current) 194 194 + } 195 195 + 196 196 + return changes, scanner.Err() 197 197 + } 198 198 + 199 199 + // parseChangeOutput parses the output of pijul change <hash> 200 200 + // 201 201 + // Actual pijul output format: 202 202 + // 203 203 + // message = 'some message' 204 204 + // timestamp = '2026-02-13T10:48:48.153366436Z' 205 205 + // 206 206 + // [[authors]] 207 207 + // key = '51vRw7nuTkQZMxpJ8CtV1bmLNFyPngpPee8WQt1bZnJM' 208 208 + // 209 209 + // # Dependencies 210 210 + // [2] HASH # 211 211 + // 212 212 + // # Hunks 213 213 + // ... 214 214 + func parseChangeOutput(hash string, output []byte) (*Change, error) { 215 215 + change := &Change{Hash: hash} 216 216 + 217 217 + scanner := bufio.NewScanner(bytes.NewReader(output)) 218 218 + inDeps := false 219 219 + inIdentity := false // inside [identity] unhashed section 220 220 + 221 221 + for scanner.Scan() { 222 222 + line := scanner.Text() 223 223 + 224 224 + // TOML-style key = 'value' lines at the top level 225 225 + if strings.HasPrefix(line, "message = ") { 226 226 + change.Message = unquoteTOMLValue(strings.TrimPrefix(line, "message = ")) 227 227 + inDeps = false 228 228 + inIdentity = false 229 229 + continue 230 230 + } 231 231 + 232 232 + if strings.HasPrefix(line, "timestamp = ") { 233 233 + ts := unquoteTOMLValue(strings.TrimPrefix(line, "timestamp = ")) 234 234 + if t, err := parseTimestamp(ts); err == nil { 235 235 + change.Timestamp = t 236 236 + } else { 237 237 + slog.Warn("failed to parse pijul change timestamp", "hash", hash, "value", ts, "error", err) 238 238 + } 239 239 + inDeps = false 240 240 + inIdentity = false 241 241 + continue 242 242 + } 243 243 + 244 244 + // Author key lines: key = '...' 245 245 + if strings.HasPrefix(line, "key = ") { 246 246 + name := unquoteTOMLValue(strings.TrimPrefix(line, "key = ")) 247 247 + change.Authors = append(change.Authors, Author{Name: name}) 248 248 + continue 249 249 + } 250 250 + 251 251 + // DID in hashed [[authors]]: did = 'did:plc:...' 252 252 + if !inIdentity && strings.HasPrefix(line, "did = ") { 253 253 + did := unquoteTOMLValue(strings.TrimPrefix(line, "did = ")) 254 254 + change.Authors = append(change.Authors, Author{DID: did}) 255 255 + continue 256 256 + } 257 257 + 258 258 + // Unhashed [identity] section — written by knot server at push time 259 259 + if line == "[identity]" { 260 260 + inIdentity = true 261 261 + inDeps = false 262 262 + continue 263 263 + } 264 264 + 265 265 + // did = 'did:plc:...' inside [identity] 266 266 + if inIdentity && strings.HasPrefix(line, "did = ") { 267 267 + did := unquoteTOMLValue(strings.TrimPrefix(line, "did = ")) 268 268 + // Attach DID to the last author, or create a synthetic author entry 269 269 + if len(change.Authors) > 0 { 270 270 + change.Authors[len(change.Authors)-1].DID = did 271 271 + } else { 272 272 + change.Authors = append(change.Authors, Author{DID: did}) 273 273 + } 274 274 + continue 275 275 + } 276 276 + 277 277 + // Section headers 278 278 + if strings.HasPrefix(line, "# Dependencies") { 279 279 + inDeps = true 280 280 + inIdentity = false 281 281 + continue 282 282 + } 283 283 + if strings.HasPrefix(line, "# ") { 284 284 + inDeps = false 285 285 + inIdentity = false 286 286 + continue 287 287 + } 288 288 + if strings.HasPrefix(line, "[") && line != "[identity]" { 289 289 + inIdentity = false 290 290 + } 291 291 + 292 292 + // Dependency lines: "[2] HASH # optional comment" 293 293 + if inDeps && strings.TrimSpace(line) != "" { 294 294 + depLine := strings.TrimSpace(line) 295 295 + // Strip leading "[N] " prefix 296 296 + if idx := strings.Index(depLine, "] "); idx != -1 { 297 297 + depLine = depLine[idx+2:] 298 298 + } 299 299 + // Strip trailing " # comment" 300 300 + if idx := strings.Index(depLine, " #"); idx != -1 { 301 301 + depLine = depLine[:idx] 302 302 + } 303 303 + depLine = strings.TrimSpace(depLine) 304 304 + if depLine != "" { 305 305 + change.Dependencies = append(change.Dependencies, depLine) 306 306 + } 307 307 + continue 308 308 + } 309 309 + } 310 310 + 311 311 + return change, scanner.Err() 312 312 + } 313 313 + 314 314 + // unquoteTOMLValue strips surrounding single or double quotes from a TOML value. 315 315 + func unquoteTOMLValue(s string) string { 316 316 + s = strings.TrimSpace(s) 317 317 + if len(s) >= 2 { 318 318 + if (s[0] == '\'' && s[len(s)-1] == '\'') || (s[0] == '"' && s[len(s)-1] == '"') { 319 319 + return s[1 : len(s)-1] 320 320 + } 321 321 + } 322 322 + return s 323 323 + } 324 324 + 325 325 + // parseAuthor parses an author string like "Name <email>" 326 326 + func parseAuthor(s string) Author { 327 327 + s = strings.TrimSpace(s) 328 328 + 329 329 + // Try to extract email from angle brackets 330 330 + if start := strings.Index(s, "<"); start != -1 { 331 331 + if end := strings.Index(s, ">"); end > start { 332 332 + return Author{ 333 333 + Name: strings.TrimSpace(s[:start]), 334 334 + Email: strings.TrimSpace(s[start+1 : end]), 335 335 + } 336 336 + } 337 337 + } 338 338 + 339 339 + return Author{Name: s} 340 340 + } 341 341 + 342 342 + // parseTimestamp parses pijul timestamp formats 343 343 + func parseTimestamp(s string) (time.Time, error) { 344 344 + s = strings.TrimSpace(s) 345 345 + 346 346 + // Try RFC3339 first (pijul's primary format) 347 347 + if t, err := time.Parse(time.RFC3339, s); err == nil { 348 348 + return t, nil 349 349 + } 350 350 + if t, err := time.Parse(time.RFC3339Nano, s); err == nil { 351 351 + return t, nil 352 352 + } 353 353 + 354 354 + // RFC 1123Z / RFC 2822 style: "Fri, 13 Feb 2026 10:48:48 +0000" 355 355 + // This is the actual format pijul log outputs. 356 356 + if t, err := time.Parse(time.RFC1123Z, s); err == nil { 357 357 + return t, nil 358 358 + } 359 359 + if t, err := time.Parse(time.RFC1123, s); err == nil { 360 360 + return t, nil 361 361 + } 362 362 + 363 363 + // Fallback: space-separated with timezone offset 364 364 + if t, err := time.Parse("2006-01-02 15:04:05 -0700", s); err == nil { 365 365 + return t, nil 366 366 + } 367 367 + 368 368 + // Fallback: no timezone, assume UTC 369 369 + if t, err := time.ParseInLocation("2006-01-02 15:04:05", s, time.UTC); err == nil { 370 370 + return t, nil 371 371 + } 372 372 + 373 373 + return time.Time{}, fmt.Errorf("unable to parse timestamp: %s", s) 374 374 + } 375 375 + 376 376 + // LatestChangeInChannel returns the most recent change on the given channel, 377 377 + // or nil if the channel has no changes. The channel name overrides whatever 378 378 + // channelName is set on the PijulRepo instance. 379 379 + func (p *PijulRepo) LatestChangeInChannel(channelName string) (*Change, error) { 380 380 + args := []string{"--offset", "0", "--limit", "1", "--channel", channelName} 381 381 + output, err := p.log(args...) 382 382 + if err != nil { 383 383 + if isNoChangesError(err) { 384 384 + return nil, nil 385 385 + } 386 386 + return nil, fmt.Errorf("pijul log --channel %s: %w", channelName, err) 387 387 + } 388 388 + changes, err := parseLogOutput(output) 389 389 + if err != nil { 390 390 + return nil, err 391 391 + } 392 392 + if len(changes) == 0 { 393 393 + return nil, nil 394 394 + } 395 395 + return &changes[0], nil 396 396 + } 397 397 + 398 398 + // LogEntry is a single change with its sequence position (oldest = 0). 399 399 + type LogEntry struct { 400 400 + Pos uint64 401 401 + Hash string 402 402 + State string 403 403 + } 404 404 + 405 405 + // LogWithState returns all changes in the channel in oldest-first order with 406 406 + // sequence positions (0 = oldest) and Merkle state hashes. Used by the pijul 407 407 + // HTTP remote protocol to serve ?changelist and ?state endpoints. 408 408 + func (p *PijulRepo) LogWithState(channelName string) ([]LogEntry, error) { 409 409 + args := []string{"--state"} 410 410 + if channelName != "" { 411 411 + args = append(args, "--channel", channelName) 412 412 + } 413 413 + output, err := p.log(args...) 414 414 + if err != nil { 415 415 + if isNoChangesError(err) { 416 416 + return nil, nil 417 417 + } 418 418 + return nil, fmt.Errorf("pijul log --state --channel %s: %w", channelName, err) 419 419 + } 420 420 + 421 421 + changes, err := parseLogOutput(output) 422 422 + if err != nil { 423 423 + return nil, err 424 424 + } 425 425 + 426 426 + // parseLogOutput returns newest-first; reverse to oldest-first and assign positions. 427 427 + entries := make([]LogEntry, len(changes)) 428 428 + for i, c := range changes { 429 429 + entries[len(changes)-1-i] = LogEntry{ 430 430 + Pos: uint64(len(changes) - 1 - i), 431 431 + Hash: c.Hash, 432 432 + State: c.State, 433 433 + } 434 434 + } 435 435 + return entries, nil 436 436 + } 437 437 + 438 438 + // ChannelState returns the Merkle state hash of the given channel after the 439 439 + // most recent change. It runs `pijul log --state --limit 1 --channel <channel>` 440 440 + // and parses the "State: HASH" line. Returns "" if the channel has no changes. 441 441 + func (p *PijulRepo) ChannelState(channelName string) (string, error) { 442 442 + args := []string{"--state", "--limit", "1", "--channel", channelName} 443 443 + output, err := p.log(args...) 444 444 + if err != nil { 445 445 + if isNoChangesError(err) { 446 446 + return "", nil 447 447 + } 448 448 + return "", fmt.Errorf("pijul log --state --channel %s: %w", channelName, err) 449 449 + } 450 450 + return parseStateFromLog(output), nil 451 451 + } 452 452 + 453 453 + // parseStateFromLog extracts the "State: HASH" value from pijul log --state output. 454 454 + func parseStateFromLog(output []byte) string { 455 455 + scanner := bufio.NewScanner(bytes.NewReader(output)) 456 456 + for scanner.Scan() { 457 457 + line := scanner.Text() 458 458 + if strings.HasPrefix(line, "State: ") { 459 459 + return strings.TrimPrefix(line, "State: ") 460 460 + } 461 461 + } 462 462 + return "" 463 463 + } 464 464 + 465 465 + // ChangeJSON represents the JSON output format for pijul log --json 466 466 + type ChangeJSON struct { 467 467 + Hash string `json:"hash"` 468 468 + Authors []string `json:"authors"` 469 469 + Message string `json:"message"` 470 470 + Timestamp string `json:"timestamp"` 471 471 + Dependencies []string `json:"dependencies,omitempty"` 472 472 + } 473 473 + 474 474 + // ChangesJSON returns changes using JSON output format (if available in pijul version) 475 475 + func (p *PijulRepo) ChangesJSON(offset, limit int) ([]Change, error) { 476 476 + args := []string{ 477 477 + "--offset", strconv.Itoa(offset), 478 478 + "-n", strconv.Itoa(limit), 479 479 + "--json", 480 480 + } 481 481 + 482 482 + if p.channelName != "" { 483 483 + args = append(args, "--channel", p.channelName) 484 484 + } 485 485 + 486 486 + output, err := p.log(args...) 487 487 + if err != nil { 488 488 + // Fall back to text parsing if JSON not supported 489 489 + return p.Changes(offset, limit) 490 490 + } 491 491 + 492 492 + var jsonChanges []ChangeJSON 493 493 + if err := json.Unmarshal(output, &jsonChanges); err != nil { 494 494 + // Fall back to text parsing if JSON parsing fails 495 495 + return p.Changes(offset, limit) 496 496 + } 497 497 + 498 498 + changes := make([]Change, len(jsonChanges)) 499 499 + for i, jc := range jsonChanges { 500 500 + changes[i] = Change{ 501 501 + Hash: jc.Hash, 502 502 + Message: jc.Message, 503 503 + Dependencies: jc.Dependencies, 504 504 + } 505 505 + 506 506 + for _, authorStr := range jc.Authors { 507 507 + changes[i].Authors = append(changes[i].Authors, parseAuthor(authorStr)) 508 508 + } 509 509 + 510 510 + if t, err := parseTimestamp(jc.Timestamp); err == nil { 511 511 + changes[i].Timestamp = t 512 512 + } else if jc.Timestamp != "" { 513 513 + slog.Warn("failed to parse pijul JSON timestamp", "hash", jc.Hash, "value", jc.Timestamp, "error", err) 514 514 + } 515 515 + } 516 516 + 517 517 + return changes, nil 518 518 + }

+160

knotserver/pijul/channel.go

reviewed

··· 1 1 + package pijul 2 2 + 3 3 + import ( 4 4 + "bufio" 5 5 + "bytes" 6 6 + "fmt" 7 7 + "strings" 8 8 + ) 9 9 + 10 10 + // Channel represents a Pijul channel (analogous to a Git branch) 11 11 + type Channel struct { 12 12 + Name string `json:"name"` 13 13 + IsCurrent bool `json:"is_current,omitempty"` 14 14 + } 15 15 + 16 16 + // Channels returns the list of channels in the repository 17 17 + func (p *PijulRepo) Channels() ([]Channel, error) { 18 18 + output, err := p.channelCmd() 19 19 + if err != nil { 20 20 + return nil, fmt.Errorf("listing channels: %w", err) 21 21 + } 22 22 + 23 23 + return parseChannelOutput(output) 24 24 + } 25 25 + 26 26 + // parseChannelOutput parses the output of pijul channel 27 27 + // Expected format: 28 28 + // 29 29 + // * main 30 30 + // feature-branch 31 31 + // another-branch 32 32 + func parseChannelOutput(output []byte) ([]Channel, error) { 33 33 + var channels []Channel 34 34 + scanner := bufio.NewScanner(bytes.NewReader(output)) 35 35 + 36 36 + for scanner.Scan() { 37 37 + line := scanner.Text() 38 38 + if strings.TrimSpace(line) == "" { 39 39 + continue 40 40 + } 41 41 + 42 42 + isCurrent := strings.HasPrefix(line, "* ") 43 43 + name := strings.TrimSpace(strings.TrimPrefix(line, "* ")) 44 44 + name = strings.TrimSpace(strings.TrimPrefix(name, " ")) 45 45 + 46 46 + if name != "" { 47 47 + channels = append(channels, Channel{ 48 48 + Name: name, 49 49 + IsCurrent: isCurrent, 50 50 + }) 51 51 + } 52 52 + } 53 53 + 54 54 + return channels, scanner.Err() 55 55 + } 56 56 + 57 57 + // ChannelOptions options for channel listing 58 58 + type ChannelOptions struct { 59 59 + Limit int 60 60 + Offset int 61 61 + } 62 62 + 63 63 + // ChannelsWithOptions returns channels with pagination 64 64 + func (p *PijulRepo) ChannelsWithOptions(opts *ChannelOptions) ([]Channel, error) { 65 65 + channels, err := p.Channels() 66 66 + if err != nil { 67 67 + return nil, err 68 68 + } 69 69 + 70 70 + if opts == nil { 71 71 + return channels, nil 72 72 + } 73 73 + 74 74 + // Apply offset 75 75 + if opts.Offset > 0 { 76 76 + if opts.Offset >= len(channels) { 77 77 + return []Channel{}, nil 78 78 + } 79 79 + channels = channels[opts.Offset:] 80 80 + } 81 81 + 82 82 + // Apply limit 83 83 + if opts.Limit > 0 && opts.Limit < len(channels) { 84 84 + channels = channels[:opts.Limit] 85 85 + } 86 86 + 87 87 + return channels, nil 88 88 + } 89 89 + 90 90 + // CreateChannel creates a new channel 91 91 + func (p *PijulRepo) CreateChannel(name string) error { 92 92 + _, err := p.channelCmd("new", name) 93 93 + return err 94 94 + } 95 95 + 96 96 + // DeleteChannel deletes a channel 97 97 + func (p *PijulRepo) DeleteChannel(name string) error { 98 98 + _, err := p.channelCmd("delete", name) 99 99 + return err 100 100 + } 101 101 + 102 102 + // RenameChannel renames a channel 103 103 + func (p *PijulRepo) RenameChannel(oldName, newName string) error { 104 104 + _, err := p.channelCmd("rename", oldName, newName) 105 105 + return err 106 106 + } 107 107 + 108 108 + // SwitchChannel switches to a different channel 109 109 + func (p *PijulRepo) SwitchChannel(name string) error { 110 110 + _, err := p.channelCmd("switch", name) 111 111 + if err != nil { 112 112 + return fmt.Errorf("switching to channel %s: %w", name, err) 113 113 + } 114 114 + p.channelName = name 115 115 + return nil 116 116 + } 117 117 + 118 118 + // CurrentChannelName returns the name of the current channel 119 119 + func (p *PijulRepo) CurrentChannelName() (string, error) { 120 120 + channels, err := p.Channels() 121 121 + if err != nil { 122 122 + return "", err 123 123 + } 124 124 + 125 125 + for _, ch := range channels { 126 126 + if ch.IsCurrent { 127 127 + return ch.Name, nil 128 128 + } 129 129 + } 130 130 + 131 131 + // If no current channel marked, default to "main" 132 132 + return "main", nil 133 133 + } 134 134 + 135 135 + // ForkChannel creates a new channel from an existing one 136 136 + // This is equivalent to Git's "git checkout -b newbranch oldbranch" 137 137 + func (p *PijulRepo) ForkChannel(newName, fromChannel string) error { 138 138 + args := []string{"fork", newName} 139 139 + if fromChannel != "" { 140 140 + args = append(args, "--channel", fromChannel) 141 141 + } 142 142 + _, err := p.channelCmd(args...) 143 143 + return err 144 144 + } 145 145 + 146 146 + // ChannelExists checks if a channel exists 147 147 + func (p *PijulRepo) ChannelExists(name string) (bool, error) { 148 148 + channels, err := p.Channels() 149 149 + if err != nil { 150 150 + return false, err 151 151 + } 152 152 + 153 153 + for _, ch := range channels { 154 154 + if ch.Name == name { 155 155 + return true, nil 156 156 + } 157 157 + } 158 158 + 159 159 + return false, nil 160 160 + }

+81

knotserver/pijul/cmd.go

reviewed

··· 1 1 + package pijul 2 2 + 3 3 + import ( 4 4 + "bytes" 5 5 + "fmt" 6 6 + "os/exec" 7 7 + ) 8 8 + 9 9 + const ( 10 10 + fieldSeparator = "\x1f" // ASCII Unit Separator 11 11 + recordSeparator = "\x1e" // ASCII Record Separator 12 12 + ) 13 13 + 14 14 + // runPijulCmd executes a pijul command in the repository directory 15 15 + func (p *PijulRepo) runPijulCmd(command string, extraArgs ...string) ([]byte, error) { 16 16 + var args []string 17 17 + args = append(args, command) 18 18 + args = append(args, extraArgs...) 19 19 + 20 20 + cmd := exec.Command("pijul", args...) 21 21 + cmd.Dir = p.path 22 22 + 23 23 + var stdout, stderr bytes.Buffer 24 24 + cmd.Stdout = &stdout 25 25 + cmd.Stderr = &stderr 26 26 + 27 27 + err := cmd.Run() 28 28 + if err != nil { 29 29 + if exitErr, ok := err.(*exec.ExitError); ok { 30 30 + return nil, fmt.Errorf("%w, stderr: %s", exitErr, stderr.String()) 31 31 + } 32 32 + return nil, fmt.Errorf("pijul %s: %w", command, err) 33 33 + } 34 34 + 35 35 + return stdout.Bytes(), nil 36 36 + } 37 37 + 38 38 + // runPijulCmdWithStdin executes a pijul command with stdin input 39 39 + func (p *PijulRepo) runPijulCmdWithStdin(stdin []byte, command string, extraArgs ...string) ([]byte, error) { 40 40 + var args []string 41 41 + args = append(args, command) 42 42 + args = append(args, extraArgs...) 43 43 + 44 44 + cmd := exec.Command("pijul", args...) 45 45 + cmd.Dir = p.path 46 46 + cmd.Stdin = bytes.NewReader(stdin) 47 47 + 48 48 + var stdout, stderr bytes.Buffer 49 49 + cmd.Stdout = &stdout 50 50 + cmd.Stderr = &stderr 51 51 + 52 52 + err := cmd.Run() 53 53 + if err != nil { 54 54 + if exitErr, ok := err.(*exec.ExitError); ok { 55 55 + return nil, fmt.Errorf("%w, stderr: %s", exitErr, stderr.String()) 56 56 + } 57 57 + return nil, fmt.Errorf("pijul %s: %w", command, err) 58 58 + } 59 59 + 60 60 + return stdout.Bytes(), nil 61 61 + } 62 62 + 63 63 + // log runs pijul log with arguments 64 64 + func (p *PijulRepo) log(extraArgs ...string) ([]byte, error) { 65 65 + return p.runPijulCmd("log", extraArgs...) 66 66 + } 67 67 + 68 68 + // channelCmd runs pijul channel with arguments 69 69 + func (p *PijulRepo) channelCmd(extraArgs ...string) ([]byte, error) { 70 70 + return p.runPijulCmd("channel", extraArgs...) 71 71 + } 72 72 + 73 73 + // diff runs pijul diff with arguments 74 74 + func (p *PijulRepo) diff(extraArgs ...string) ([]byte, error) { 75 75 + return p.runPijulCmd("diff", extraArgs...) 76 76 + } 77 77 + 78 78 + // change runs pijul change (show change details) with arguments 79 79 + func (p *PijulRepo) change(extraArgs ...string) ([]byte, error) { 80 80 + return p.runPijulCmd("change", extraArgs...) 81 81 + }

+73

knotserver/pijul/diff.go

reviewed

··· 1 1 + package pijul 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + ) 6 6 + 7 7 + // Diff represents the difference between two states 8 8 + type Diff struct { 9 9 + Raw string `json:"raw"` 10 10 + Files []FileDiff `json:"files,omitempty"` 11 11 + Stats *DiffStats `json:"stats,omitempty"` 12 12 + } 13 13 + 14 14 + // FileDiff represents changes to a single file 15 15 + type FileDiff struct { 16 16 + Path string `json:"path"` 17 17 + OldPath string `json:"old_path,omitempty"` // for renames 18 18 + Status string `json:"status"` // added, modified, deleted, renamed 19 19 + Additions int `json:"additions"` 20 20 + Deletions int `json:"deletions"` 21 21 + Patch string `json:"patch,omitempty"` 22 22 + } 23 23 + 24 24 + // DiffStats contains summary statistics for a diff 25 25 + type DiffStats struct { 26 26 + FilesChanged int `json:"files_changed"` 27 27 + Additions int `json:"additions"` 28 28 + Deletions int `json:"deletions"` 29 29 + } 30 30 + 31 31 + // Diff returns the diff of uncommitted changes 32 32 + func (p *PijulRepo) Diff() (*Diff, error) { 33 33 + output, err := p.diff() 34 34 + if err != nil { 35 35 + return nil, fmt.Errorf("pijul diff: %w", err) 36 36 + } 37 37 + 38 38 + return &Diff{ 39 39 + Raw: string(output), 40 40 + }, nil 41 41 + } 42 42 + 43 43 + // DiffChange returns the diff for a specific change 44 44 + func (p *PijulRepo) DiffChange(hash string) (*Diff, error) { 45 45 + output, err := p.change(hash) 46 46 + if err != nil { 47 47 + return nil, fmt.Errorf("pijul change %s: %w", hash, err) 48 48 + } 49 49 + 50 50 + return &Diff{ 51 51 + Raw: string(output), 52 52 + }, nil 53 53 + } 54 54 + 55 55 + // DiffBetween returns the diff between two channels or states 56 56 + func (p *PijulRepo) DiffBetween(from, to string) (*Diff, error) { 57 57 + args := []string{} 58 58 + if from != "" { 59 59 + args = append(args, "--channel", from) 60 60 + } 61 61 + if to != "" { 62 62 + args = append(args, "--channel", to) 63 63 + } 64 64 + 65 65 + output, err := p.diff(args...) 66 66 + if err != nil { 67 67 + return nil, fmt.Errorf("pijul diff: %w", err) 68 68 + } 69 69 + 70 70 + return &Diff{ 71 71 + Raw: string(output), 72 72 + }, nil 73 73 + }

+306

knotserver/pijul/pijul.go

reviewed

··· 1 1 + package pijul 2 2 + 3 3 + import ( 4 4 + "archive/tar" 5 5 + "bytes" 6 6 + "errors" 7 7 + "fmt" 8 8 + "io" 9 9 + "io/fs" 10 10 + "os" 11 11 + "os/exec" 12 12 + "path/filepath" 13 13 + 14 14 + securejoin "github.com/cyphar/filepath-securejoin" 15 15 + ) 16 16 + 17 17 + var ( 18 18 + ErrBinaryFile = errors.New("binary file") 19 19 + ErrNotBinaryFile = errors.New("not binary file") 20 20 + ErrNoPijulRepo = errors.New("not a pijul repository") 21 21 + ErrChannelNotFound = errors.New("channel not found") 22 22 + ErrChangeNotFound = errors.New("change not found") 23 23 + ErrPathNotFound = errors.New("path not found") 24 24 + ) 25 25 + 26 26 + // PijulRepo represents a Pijul repository 27 27 + type PijulRepo struct { 28 28 + path string 29 29 + channelName string // current channel (empty means default) 30 30 + } 31 31 + 32 32 + // Open opens a Pijul repository at the given path with optional channel 33 33 + func Open(path string, channel string) (*PijulRepo, error) { 34 34 + // Verify it's a pijul repository 35 35 + pijulDir := filepath.Join(path, ".pijul") 36 36 + if _, err := os.Stat(pijulDir); os.IsNotExist(err) { 37 37 + return nil, fmt.Errorf("%w: %s", ErrNoPijulRepo, path) 38 38 + } 39 39 + 40 40 + p := &PijulRepo{ 41 41 + path: path, 42 42 + channelName: channel, 43 43 + } 44 44 + 45 45 + // Verify channel exists if specified 46 46 + if channel != "" { 47 47 + channels, err := p.Channels() 48 48 + if err != nil { 49 49 + return nil, fmt.Errorf("listing channels: %w", err) 50 50 + } 51 51 + found := false 52 52 + for _, ch := range channels { 53 53 + if ch.Name == channel { 54 54 + found = true 55 55 + break 56 56 + } 57 57 + } 58 58 + if !found { 59 59 + return nil, fmt.Errorf("%w: %s", ErrChannelNotFound, channel) 60 60 + } 61 61 + } 62 62 + 63 63 + return p, nil 64 64 + } 65 65 + 66 66 + // PlainOpen opens a Pijul repository without setting a specific channel 67 67 + func PlainOpen(path string) (*PijulRepo, error) { 68 68 + // Verify it's a pijul repository 69 69 + pijulDir := filepath.Join(path, ".pijul") 70 70 + if _, err := os.Stat(pijulDir); os.IsNotExist(err) { 71 71 + return nil, fmt.Errorf("%w: %s", ErrNoPijulRepo, path) 72 72 + } 73 73 + 74 74 + return &PijulRepo{path: path}, nil 75 75 + } 76 76 + 77 77 + // Path returns the repository path 78 78 + func (p *PijulRepo) Path() string { 79 79 + return p.path 80 80 + } 81 81 + 82 82 + // CurrentChannel returns the current channel (or empty for default) 83 83 + func (p *PijulRepo) CurrentChannel() string { 84 84 + return p.channelName 85 85 + } 86 86 + 87 87 + // FindDefaultChannel returns the default channel name 88 88 + func (p *PijulRepo) FindDefaultChannel() (string, error) { 89 89 + channels, err := p.Channels() 90 90 + if err != nil { 91 91 + return "", err 92 92 + } 93 93 + 94 94 + // Look for 'main' first, then fall back to first channel 95 95 + for _, ch := range channels { 96 96 + if ch.Name == "main" { 97 97 + return "main", nil 98 98 + } 99 99 + } 100 100 + 101 101 + if len(channels) > 0 { 102 102 + return channels[0].Name, nil 103 103 + } 104 104 + 105 105 + return "main", nil // default 106 106 + } 107 107 + 108 108 + // SetDefaultChannel changes which channel is considered default 109 109 + // In Pijul, this would typically be done by renaming channels 110 110 + func (p *PijulRepo) SetDefaultChannel(channel string) error { 111 111 + // Pijul doesn't have a built-in default branch concept like git HEAD 112 112 + // This is typically managed at application level 113 113 + // For now, just verify the channel exists 114 114 + channels, err := p.Channels() 115 115 + if err != nil { 116 116 + return err 117 117 + } 118 118 + 119 119 + for _, ch := range channels { 120 120 + if ch.Name == channel { 121 121 + return nil 122 122 + } 123 123 + } 124 124 + 125 125 + return fmt.Errorf("%w: %s", ErrChannelNotFound, channel) 126 126 + } 127 127 + 128 128 + // FileContent reads a file from the working copy at a specific path 129 129 + // Note: Pijul doesn't have the concept of reading files at a specific revision 130 130 + // like git. We read from the working directory or need to use pijul credit. 131 131 + func (p *PijulRepo) FileContent(filePath string) ([]byte, error) { 132 132 + fullPath, err := securejoin.SecureJoin(p.path, filePath) 133 133 + if err != nil { 134 134 + return nil, fmt.Errorf("invalid path: %w", err) 135 135 + } 136 136 + 137 137 + content, err := os.ReadFile(fullPath) 138 138 + if err != nil { 139 139 + if os.IsNotExist(err) { 140 140 + return nil, fmt.Errorf("%w: %s", ErrPathNotFound, filePath) 141 141 + } 142 142 + return nil, err 143 143 + } 144 144 + 145 145 + return content, nil 146 146 + } 147 147 + 148 148 + // FileContentN reads up to cap bytes of a file 149 149 + func (p *PijulRepo) FileContentN(filePath string, cap int64) ([]byte, error) { 150 150 + fullPath, err := securejoin.SecureJoin(p.path, filePath) 151 151 + if err != nil { 152 152 + return nil, fmt.Errorf("invalid path: %w", err) 153 153 + } 154 154 + 155 155 + f, err := os.Open(fullPath) 156 156 + if err != nil { 157 157 + if os.IsNotExist(err) { 158 158 + return nil, fmt.Errorf("%w: %s", ErrPathNotFound, filePath) 159 159 + } 160 160 + return nil, err 161 161 + } 162 162 + defer f.Close() 163 163 + 164 164 + // Check if binary 165 165 + buf := make([]byte, 512) 166 166 + n, err := f.Read(buf) 167 167 + if err != nil && err != io.EOF { 168 168 + return nil, err 169 169 + } 170 170 + if isBinary(buf[:n]) { 171 171 + return nil, ErrBinaryFile 172 172 + } 173 173 + 174 174 + // Reset and read up to cap 175 175 + if _, err := f.Seek(0, 0); err != nil { 176 176 + return nil, err 177 177 + } 178 178 + 179 179 + content := make([]byte, cap) 180 180 + n, err = f.Read(content) 181 181 + if err != nil && err != io.EOF { 182 182 + return nil, err 183 183 + } 184 184 + 185 185 + return content[:n], nil 186 186 + } 187 187 + 188 188 + // RawContent reads raw file content without binary check 189 189 + func (p *PijulRepo) RawContent(filePath string) ([]byte, error) { 190 190 + fullPath, err := securejoin.SecureJoin(p.path, filePath) 191 191 + if err != nil { 192 192 + return nil, fmt.Errorf("invalid path: %w", err) 193 193 + } 194 194 + return os.ReadFile(fullPath) 195 195 + } 196 196 + 197 197 + // isBinary checks if data appears to be binary 198 198 + func isBinary(data []byte) bool { 199 199 + for _, b := range data { 200 200 + if b == 0 { 201 201 + return true 202 202 + } 203 203 + } 204 204 + return false 205 205 + } 206 206 + 207 207 + // WriteTar writes the repository contents to a tar archive 208 208 + func (p *PijulRepo) WriteTar(w io.Writer, prefix string) error { 209 209 + tw := tar.NewWriter(w) 210 210 + defer tw.Close() 211 211 + 212 212 + return filepath.Walk(p.path, func(path string, info fs.FileInfo, err error) error { 213 213 + if err != nil { 214 214 + return err 215 215 + } 216 216 + 217 217 + // Skip .pijul directory 218 218 + if info.IsDir() && filepath.Base(path) == ".pijul" { 219 219 + return filepath.SkipDir 220 220 + } 221 221 + 222 222 + relPath, err := filepath.Rel(p.path, path) 223 223 + if err != nil { 224 224 + return err 225 225 + } 226 226 + 227 227 + if relPath == "." { 228 228 + return nil 229 229 + } 230 230 + 231 231 + header, err := tar.FileInfoHeader(info, "") 232 232 + if err != nil { 233 233 + return err 234 234 + } 235 235 + 236 236 + header.Name = filepath.Join(prefix, relPath) 237 237 + 238 238 + if err := tw.WriteHeader(header); err != nil { 239 239 + return err 240 240 + } 241 241 + 242 242 + if !info.IsDir() { 243 243 + if err := copyFileToTar(tw, path); err != nil { 244 244 + return err 245 245 + } 246 246 + } 247 247 + 248 248 + return nil 249 249 + }) 250 250 + } 251 251 + 252 252 + // copyFileToTar copies a single file into a tar writer, closing the file before returning. 253 253 + func copyFileToTar(tw *tar.Writer, path string) error { 254 254 + f, err := os.Open(path) 255 255 + if err != nil { 256 256 + return err 257 257 + } 258 258 + defer f.Close() 259 259 + _, err = io.Copy(tw, f) 260 260 + return err 261 261 + } 262 262 + 263 263 + // InitRepo initializes a new Pijul repository 264 264 + func InitRepo(path string, bare bool) error { 265 265 + if err := os.MkdirAll(path, 0755); err != nil { 266 266 + return fmt.Errorf("creating directory: %w", err) 267 267 + } 268 268 + 269 269 + args := []string{"init"} 270 270 + if bare { 271 271 + // Pijul doesn't have explicit bare repos like git 272 272 + // A "bare" repo is typically just a repo without a working directory 273 273 + args = append(args, "--kind=bare") 274 274 + } 275 275 + 276 276 + cmd := exec.Command("pijul", args...) 277 277 + cmd.Dir = path 278 278 + 279 279 + var stderr bytes.Buffer 280 280 + cmd.Stderr = &stderr 281 281 + 282 282 + if err := cmd.Run(); err != nil { 283 283 + return fmt.Errorf("pijul init: %w, stderr: %s", err, stderr.String()) 284 284 + } 285 285 + 286 286 + return nil 287 287 + } 288 288 + 289 289 + // Clone clones a Pijul repository 290 290 + func Clone(url, destPath string, channel string) error { 291 291 + args := []string{"clone", url, destPath} 292 292 + if channel != "" { 293 293 + args = append(args, "--channel", channel) 294 294 + } 295 295 + 296 296 + cmd := exec.Command("pijul", args...) 297 297 + 298 298 + var stderr bytes.Buffer 299 299 + cmd.Stderr = &stderr 300 300 + 301 301 + if err := cmd.Run(); err != nil { 302 302 + return fmt.Errorf("pijul clone: %w, stderr: %s", err, stderr.String()) 303 303 + } 304 304 + 305 305 + return nil 306 306 + }

+131

knotserver/pijul/repo.go

reviewed

··· 1 1 + package pijul 2 2 + 3 3 + import ( 4 4 + "bytes" 5 5 + "fmt" 6 6 + "os" 7 7 + "os/exec" 8 8 + ) 9 9 + 10 10 + // InitBare initializes a bare Pijul repository 11 11 + func InitBare(repoPath string) error { 12 12 + if err := os.MkdirAll(repoPath, 0755); err != nil { 13 13 + return fmt.Errorf("creating directory: %w", err) 14 14 + } 15 15 + 16 16 + cmd := exec.Command("pijul", "init") 17 17 + cmd.Dir = repoPath 18 18 + 19 19 + var stderr bytes.Buffer 20 20 + cmd.Stderr = &stderr 21 21 + 22 22 + if err := cmd.Run(); err != nil { 23 23 + return fmt.Errorf("pijul init: %w, stderr: %s", err, stderr.String()) 24 24 + } 25 25 + 26 26 + // remove .ignore auto-generated by pijul init 27 27 + os.Remove(fmt.Sprintf("%s/.ignore", repoPath)) 28 28 + 29 29 + return nil 30 30 + } 31 31 + 32 32 + // Fork clones a repository to a new location 33 33 + func Fork(srcPath, destPath string) error { 34 34 + // For local fork, we can use pijul clone 35 35 + cmd := exec.Command("pijul", "clone", srcPath, destPath) 36 36 + 37 37 + var stderr bytes.Buffer 38 38 + cmd.Stderr = &stderr 39 39 + 40 40 + if err := cmd.Run(); err != nil { 41 41 + return fmt.Errorf("pijul clone: %w, stderr: %s", err, stderr.String()) 42 42 + } 43 43 + 44 44 + return nil 45 45 + } 46 46 + 47 47 + // Push pushes changes to a remote 48 48 + func (p *PijulRepo) Push(remote string, channel string) error { 49 49 + args := []string{remote} 50 50 + if channel != "" { 51 51 + args = append(args, "--channel", channel) 52 52 + } 53 53 + 54 54 + _, err := p.runPijulCmd("push", args...) 55 55 + return err 56 56 + } 57 57 + 58 58 + // Pull pulls changes from a remote 59 59 + func (p *PijulRepo) Pull(remote string, channel string) error { 60 60 + args := []string{remote} 61 61 + if channel != "" { 62 62 + args = append(args, "--channel", channel) 63 63 + } 64 64 + 65 65 + _, err := p.runPijulCmd("pull", args...) 66 66 + return err 67 67 + } 68 68 + 69 69 + // Apply applies a change to the repository 70 70 + func (p *PijulRepo) Apply(changeHash string) error { 71 71 + args := []string{changeHash} 72 72 + if p.channelName != "" { 73 73 + args = append(args, "--channel", p.channelName) 74 74 + } 75 75 + _, err := p.runPijulCmd("apply", args...) 76 76 + return err 77 77 + } 78 78 + 79 79 + // Unrecord removes a change from the channel and resets the working copy 80 80 + // to match (like git reset --hard). 81 81 + func (p *PijulRepo) Unrecord(changeHash string) error { 82 82 + args := []string{changeHash} 83 83 + if p.channelName != "" { 84 84 + args = append(args, "--channel", p.channelName) 85 85 + } 86 86 + if _, err := p.runPijulCmd("unrecord", args...); err != nil { 87 87 + return err 88 88 + } 89 89 + 90 90 + // Reset working copy to match the channel state 91 91 + resetArgs := []string{} 92 92 + if p.channelName != "" { 93 93 + resetArgs = append(resetArgs, "--channel", p.channelName) 94 94 + } 95 95 + _, err := p.runPijulCmd("reset", resetArgs...) 96 96 + return err 97 97 + } 98 98 + 99 99 + // Record creates a new change (like git commit) 100 100 + func (p *PijulRepo) Record(message string, authors []Author) error { 101 101 + args := []string{"-m", message} 102 102 + 103 103 + for _, author := range authors { 104 104 + authorStr := author.Name 105 105 + if author.Email != "" { 106 106 + authorStr = fmt.Sprintf("%s <%s>", author.Name, author.Email) 107 107 + } 108 108 + args = append(args, "--author", authorStr) 109 109 + } 110 110 + 111 111 + if p.channelName != "" { 112 112 + args = append(args, "--channel", p.channelName) 113 113 + } 114 114 + 115 115 + _, err := p.runPijulCmd("record", args...) 116 116 + return err 117 117 + } 118 118 + 119 119 + // Add adds files to be tracked 120 120 + func (p *PijulRepo) Add(paths ...string) error { 121 121 + args := append([]string{}, paths...) 122 122 + _, err := p.runPijulCmd("add", args...) 123 123 + return err 124 124 + } 125 125 + 126 126 + // Remove removes files from tracking 127 127 + func (p *PijulRepo) Remove(paths ...string) error { 128 128 + args := append([]string{}, paths...) 129 129 + _, err := p.runPijulCmd("remove", args...) 130 130 + return err 131 131 + }

+197

knotserver/pijul/tree.go

reviewed

··· 1 1 + package pijul 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "fmt" 6 6 + "io/fs" 7 7 + "os" 8 8 + "path" 9 9 + "path/filepath" 10 10 + "strings" 11 11 + 12 12 + securejoin "github.com/cyphar/filepath-securejoin" 13 13 + "tangled.org/core/types" 14 14 + ) 15 15 + 16 16 + // TreeEntry represents a file or directory in the repository tree 17 17 + type TreeEntry struct { 18 18 + Name string `json:"name"` 19 19 + Mode fs.FileMode `json:"mode"` 20 20 + Size int64 `json:"size"` 21 21 + IsDir bool `json:"is_dir"` 22 22 + } 23 23 + 24 24 + // FileTree returns the file tree at the given path 25 25 + // For Pijul, we read directly from the working directory 26 26 + func (p *PijulRepo) FileTree(ctx context.Context, treePath string) ([]types.NiceTree, error) { 27 27 + fullPath, err := securejoin.SecureJoin(p.path, treePath) 28 28 + if err != nil { 29 29 + return nil, fmt.Errorf("invalid path: %w", err) 30 30 + } 31 31 + 32 32 + info, err := os.Stat(fullPath) 33 33 + if err != nil { 34 34 + if os.IsNotExist(err) { 35 35 + return nil, ErrPathNotFound 36 36 + } 37 37 + return nil, err 38 38 + } 39 39 + 40 40 + // If it's a file, return empty (no tree for files) 41 41 + if !info.IsDir() { 42 42 + return []types.NiceTree{}, nil 43 43 + } 44 44 + 45 45 + entries, err := os.ReadDir(fullPath) 46 46 + if err != nil { 47 47 + return nil, err 48 48 + } 49 49 + 50 50 + trees := make([]types.NiceTree, 0, len(entries)) 51 51 + 52 52 + for _, entry := range entries { 53 53 + // Skip .pijul directory 54 54 + if entry.Name() == ".pijul" { 55 55 + continue 56 56 + } 57 57 + 58 58 + info, err := entry.Info() 59 59 + if err != nil { 60 60 + continue 61 61 + } 62 62 + 63 63 + trees = append(trees, types.NiceTree{ 64 64 + Name: entry.Name(), 65 65 + Mode: fileModeToString(info.Mode()), 66 66 + Size: info.Size(), 67 67 + // LastCommit would require additional work to implement 68 68 + // For now, we leave it nil 69 69 + }) 70 70 + } 71 71 + 72 72 + return trees, nil 73 73 + } 74 74 + 75 75 + // fileModeToString converts fs.FileMode to octal string representation 76 76 + func fileModeToString(mode fs.FileMode) string { 77 77 + // Convert to git-style mode representation 78 78 + if mode.IsDir() { 79 79 + return "040000" 80 80 + } 81 81 + if mode&fs.ModeSymlink != 0 { 82 82 + return "120000" 83 83 + } 84 84 + if mode&0111 != 0 { 85 85 + return "100755" 86 86 + } 87 87 + return "100644" 88 88 + } 89 89 + 90 90 + // Walk callback type 91 91 + type WalkCallback func(path string, info fs.FileInfo, isDir bool) error 92 92 + 93 93 + // Walk traverses the file tree 94 94 + func (p *PijulRepo) Walk(ctx context.Context, root string, cb WalkCallback) error { 95 95 + startPath, err := securejoin.SecureJoin(p.path, root) 96 96 + if err != nil { 97 97 + return fmt.Errorf("invalid path: %w", err) 98 98 + } 99 99 + 100 100 + return filepath.WalkDir(startPath, func(walkPath string, d fs.DirEntry, err error) error { 101 101 + if err != nil { 102 102 + return err 103 103 + } 104 104 + 105 105 + // Check context 106 106 + select { 107 107 + case <-ctx.Done(): 108 108 + return ctx.Err() 109 109 + default: 110 110 + } 111 111 + 112 112 + // Skip .pijul directory 113 113 + if d.IsDir() && filepath.Base(walkPath) == ".pijul" { 114 114 + return filepath.SkipDir 115 115 + } 116 116 + 117 117 + // Get relative path 118 118 + relPath, err := filepath.Rel(p.path, walkPath) 119 119 + if err != nil { 120 120 + return err 121 121 + } 122 122 + 123 123 + if relPath == "." { 124 124 + return nil 125 125 + } 126 126 + 127 127 + info, err := d.Info() 128 128 + if err != nil { 129 129 + return err 130 130 + } 131 131 + 132 132 + return cb(relPath, info, d.IsDir()) 133 133 + }) 134 134 + } 135 135 + 136 136 + // ListFiles returns all tracked files in the repository 137 137 + func (p *PijulRepo) ListFiles() ([]string, error) { 138 138 + output, err := p.runPijulCmd("ls") 139 139 + if err != nil { 140 140 + return nil, err 141 141 + } 142 142 + 143 143 + lines := strings.Split(strings.TrimSpace(string(output)), "\n") 144 144 + if len(lines) == 1 && lines[0] == "" { 145 145 + return []string{}, nil 146 146 + } 147 147 + 148 148 + return lines, nil 149 149 + } 150 150 + 151 151 + // IsTracked checks if a file is tracked by Pijul 152 152 + func (p *PijulRepo) IsTracked(filePath string) (bool, error) { 153 153 + files, err := p.ListFiles() 154 154 + if err != nil { 155 155 + return false, err 156 156 + } 157 157 + 158 158 + for _, f := range files { 159 159 + if f == filePath { 160 160 + return true, nil 161 161 + } 162 162 + } 163 163 + 164 164 + return false, nil 165 165 + } 166 166 + 167 167 + // FileExists checks if a file exists in the working directory 168 168 + func (p *PijulRepo) FileExists(filePath string) bool { 169 169 + fullPath, err := securejoin.SecureJoin(p.path, filePath) 170 170 + if err != nil { 171 171 + return false 172 172 + } 173 173 + _, err = os.Stat(fullPath) 174 174 + return err == nil 175 175 + } 176 176 + 177 177 + // IsDir checks if a path is a directory 178 178 + func (p *PijulRepo) IsDir(treePath string) (bool, error) { 179 179 + fullPath, err := securejoin.SecureJoin(p.path, treePath) 180 180 + if err != nil { 181 181 + return false, fmt.Errorf("invalid path: %w", err) 182 182 + } 183 183 + info, err := os.Stat(fullPath) 184 184 + if err != nil { 185 185 + return false, err 186 186 + } 187 187 + return info.IsDir(), nil 188 188 + } 189 189 + 190 190 + // MakeNiceTree creates a NiceTree from file info 191 191 + func MakeNiceTree(name string, info fs.FileInfo) types.NiceTree { 192 192 + return types.NiceTree{ 193 193 + Name: path.Base(name), 194 194 + Mode: fileModeToString(info.Mode()), 195 195 + Size: info.Size(), 196 196 + } 197 197 + }

+349

knotserver/pijul_http.go

reviewed

··· 1 1 + package knotserver 2 2 + 3 3 + import ( 4 4 + "crypto/sha256" 5 5 + "encoding/base64" 6 6 + "encoding/json" 7 7 + "fmt" 8 8 + "io" 9 9 + "net/http" 10 10 + "os" 11 11 + "path/filepath" 12 12 + "strconv" 13 13 + "strings" 14 14 + 15 15 + "github.com/go-chi/chi/v5" 16 16 + "tangled.org/core/api/tangled" 17 17 + "tangled.org/core/knotserver/db" 18 18 + "tangled.org/core/knotserver/pijul" 19 19 + "tangled.org/core/rbac" 20 20 + ) 21 21 + 22 22 + // PijulHttpGet handles GET /{did}/{name}/.pijul — the pijul HTTP remote read protocol. 23 23 + // Dispatches on query string: ?id, ?state, ?changelist, ?change, ?tag. 24 24 + func (h *Knot) PijulHttpGet(w http.ResponseWriter, r *http.Request) { 25 25 + repoPath, ok := repoPathFromcontext(r.Context()) 26 26 + if !ok { 27 27 + http.Error(w, "repository not found", http.StatusNotFound) 28 28 + return 29 29 + } 30 30 + 31 31 + q := r.URL.Query() 32 32 + switch { 33 33 + case q.Has("id"): 34 34 + h.pijulGetId(w, repoPath, q.Get("channel")) 35 35 + case q.Has("state"): 36 36 + h.pijulGetState(w, r, repoPath, q.Get("channel"), q.Get("state")) 37 37 + case q.Has("changelist"): 38 38 + h.pijulGetChangelist(w, r, repoPath, q.Get("channel"), q.Get("changelist")) 39 39 + case q.Has("change"): 40 40 + h.pijulGetChange(w, r, repoPath, q.Get("change")) 41 41 + case q.Has("tag"): 42 42 + h.pijulGetTag(w, r, repoPath, q.Get("tag")) 43 43 + default: 44 44 + http.NotFound(w, r) 45 45 + } 46 46 + } 47 47 + 48 48 + // PijulHttpPost handles POST /{did}/{name}/.pijul — the pijul HTTP remote write protocol. 49 49 + // Dispatches on query string: ?apply (upload + apply a change), ?tagup (upload a tag). 50 50 + func (h *Knot) PijulHttpPost(w http.ResponseWriter, r *http.Request) { 51 51 + repoPath, ok := repoPathFromcontext(r.Context()) 52 52 + if !ok { 53 53 + http.Error(w, "repository not found", http.StatusNotFound) 54 54 + return 55 55 + } 56 56 + 57 57 + q := r.URL.Query() 58 58 + if hash := q.Get("apply"); hash != "" { 59 59 + h.pijulApplyChange(w, r, repoPath, hash, q.Get("to_channel")) 60 60 + } else if hash := q.Get("tagup"); hash != "" { 61 61 + h.pijulTagUp(w, r, repoPath, hash, q.Get("to_channel")) 62 62 + } else { 63 63 + http.Error(w, "unknown pijul operation", http.StatusBadRequest) 64 64 + } 65 65 + } 66 66 + 67 67 + // pijulGetId returns a stable 16-byte remote identifier for the given repo+channel. 68 68 + // The pijul client uses this to detect remote identity changes and invalidate its cache. 69 69 + func (h *Knot) pijulGetId(w http.ResponseWriter, repoPath, channel string) { 70 70 + sum := sha256.Sum256([]byte(repoPath + ":" + channel)) 71 71 + w.Header().Set("Content-Type", "application/octet-stream") 72 72 + w.Write(sum[:16]) 73 73 + } 74 74 + 75 75 + // pijulGetState returns the Merkle state at position posStr. 76 76 + // Response format: "{pos} {merkle1} {merkle2}\n" (space-separated). 77 77 + // When posStr is empty, returns the latest (newest) state. 78 78 + func (h *Knot) pijulGetState(w http.ResponseWriter, r *http.Request, repoPath, channel, posStr string) { 79 79 + pr, err := pijul.Open(repoPath, channel) 80 80 + if err != nil { 81 81 + http.Error(w, "failed to open repository", http.StatusInternalServerError) 82 82 + return 83 83 + } 84 84 + 85 85 + entries, err := pr.LogWithState(channel) 86 86 + if err != nil { 87 87 + h.l.Error("pijul log --state failed", "err", err) 88 88 + http.Error(w, "failed to read change log", http.StatusInternalServerError) 89 89 + return 90 90 + } 91 91 + 92 92 + if len(entries) == 0 { 93 93 + // Empty channel: no state yet. 94 94 + http.Error(w, "no changes in channel", http.StatusNotFound) 95 95 + return 96 96 + } 97 97 + 98 98 + var pos uint64 99 99 + if posStr == "" { 100 100 + pos = entries[len(entries)-1].Pos // latest 101 101 + } else { 102 102 + pos, err = strconv.ParseUint(posStr, 10, 64) 103 103 + if err != nil { 104 104 + http.Error(w, "invalid position", http.StatusBadRequest) 105 105 + return 106 106 + } 107 107 + if pos >= uint64(len(entries)) { 108 108 + pos = uint64(len(entries) - 1) 109 109 + } 110 110 + } 111 111 + 112 112 + entry := entries[pos] 113 113 + // Return "{pos} {merkle} {merkle}\n" 114 114 + // We use the same Merkle for both channel state and tag state (no tag support yet). 115 115 + fmt.Fprintf(w, "%d %s %s\n", entry.Pos, entry.State, entry.State) 116 116 + } 117 117 + 118 118 + // pijulGetChangelist returns all changes from position fromStr onwards (oldest-first). 119 119 + // Response format: one line per change: "{pos}.{hash}.{merkle}\n", terminated by an empty line. 120 120 + func (h *Knot) pijulGetChangelist(w http.ResponseWriter, r *http.Request, repoPath, channel, fromStr string) { 121 121 + pr, err := pijul.Open(repoPath, channel) 122 122 + if err != nil { 123 123 + http.Error(w, "failed to open repository", http.StatusInternalServerError) 124 124 + return 125 125 + } 126 126 + 127 127 + entries, err := pr.LogWithState(channel) 128 128 + if err != nil { 129 129 + h.l.Error("pijul log --state failed", "err", err) 130 130 + http.Error(w, "failed to read change log", http.StatusInternalServerError) 131 131 + return 132 132 + } 133 133 + 134 134 + var from uint64 135 135 + if fromStr != "" { 136 136 + from, err = strconv.ParseUint(fromStr, 10, 64) 137 137 + if err != nil { 138 138 + http.Error(w, "invalid from position", http.StatusBadRequest) 139 139 + return 140 140 + } 141 141 + } 142 142 + 143 143 + w.Header().Set("Content-Type", "text/plain") 144 144 + for _, e := range entries { 145 145 + if e.Pos < from { 146 146 + continue 147 147 + } 148 148 + fmt.Fprintf(w, "%d.%s.%s\n", e.Pos, e.Hash, e.State) 149 149 + } 150 150 + // Empty line signals end of changelist. 151 151 + fmt.Fprintln(w) 152 152 + } 153 153 + 154 154 + // pijulGetChange serves a single change file as raw bytes. 155 155 + // The change is read from .pijul/changes/{hash[:2]}/{hash[2:]}.change 156 156 + func (h *Knot) pijulGetChange(w http.ResponseWriter, r *http.Request, repoPath, hash string) { 157 157 + if len(hash) < 3 { 158 158 + http.Error(w, "invalid change hash", http.StatusBadRequest) 159 159 + return 160 160 + } 161 161 + changePath := filepath.Join(repoPath, ".pijul", "changes", hash[:2], hash[2:]+".change") 162 162 + data, err := os.ReadFile(changePath) 163 163 + if err != nil { 164 164 + if os.IsNotExist(err) { 165 165 + http.Error(w, "change not found", http.StatusNotFound) 166 166 + } else { 167 167 + http.Error(w, "failed to read change", http.StatusInternalServerError) 168 168 + } 169 169 + return 170 170 + } 171 171 + w.Header().Set("Content-Type", "application/octet-stream") 172 172 + w.Header().Set("Content-Length", strconv.Itoa(len(data))) 173 173 + w.Write(data) 174 174 + } 175 175 + 176 176 + // pijulGetTag serves a tag file (for tagged states). We don't support tags yet; 177 177 + // return 404 so the client falls back gracefully. 178 178 + func (h *Knot) pijulGetTag(w http.ResponseWriter, r *http.Request, repoPath, hash string) { 179 179 + http.Error(w, "tags not supported", http.StatusNotFound) 180 180 + } 181 181 + 182 182 + // pijulApplyChange handles POST ?.apply=HASH&to_channel=CHANNEL. 183 183 + // It saves the uploaded change file, applies it, and emits an SSE event. 184 184 + func (h *Knot) pijulApplyChange(w http.ResponseWriter, r *http.Request, repoPath, hash, channel string) { 185 185 + // 1. Authenticate the pusher. 186 186 + pusherDid, err := parseBearerDID(r) 187 187 + if err != nil { 188 188 + http.Error(w, "unauthorized: "+err.Error(), http.StatusForbidden) 189 189 + return 190 190 + } 191 191 + 192 192 + // 2. RBAC: verify push permission. 193 193 + ownerDid := chi.URLParam(r, "did") 194 194 + repoName := chi.URLParam(r, "name") 195 195 + repoDid, dbErr := h.db.GetRepoDid(ownerDid, repoName) 196 196 + if dbErr != nil { 197 197 + repoDid = ownerDid + "/" + repoName 198 198 + } 199 199 + ok, rbacErr := h.e.IsPushAllowed(pusherDid, rbac.ThisServer, repoDid) 200 200 + if rbacErr != nil || !ok { 201 201 + http.Error(w, "forbidden", http.StatusForbidden) 202 202 + return 203 203 + } 204 204 + 205 205 + // 3. Save the change file to disk. 206 206 + if len(hash) < 3 { 207 207 + http.Error(w, "invalid change hash", http.StatusBadRequest) 208 208 + return 209 209 + } 210 210 + changeDir := filepath.Join(repoPath, ".pijul", "changes", hash[:2]) 211 211 + if err := os.MkdirAll(changeDir, 0755); err != nil { 212 212 + http.Error(w, "failed to create change directory", http.StatusInternalServerError) 213 213 + return 214 214 + } 215 215 + changePath := filepath.Join(changeDir, hash[2:]+".change") 216 216 + 217 217 + body, err := io.ReadAll(r.Body) 218 218 + if err != nil { 219 219 + http.Error(w, "failed to read request body", http.StatusBadRequest) 220 220 + return 221 221 + } 222 222 + if err := os.WriteFile(changePath, body, 0644); err != nil { 223 223 + http.Error(w, "failed to write change file", http.StatusInternalServerError) 224 224 + return 225 225 + } 226 226 + 227 227 + // 4. Apply the change to the channel. 228 228 + if channel == "" { 229 229 + channel = "main" 230 230 + } 231 231 + pr, err := pijul.Open(repoPath, channel) 232 232 + if err != nil { 233 233 + os.Remove(changePath) 234 234 + http.Error(w, "failed to open repository", http.StatusInternalServerError) 235 235 + return 236 236 + } 237 237 + if err := pr.Apply(hash); err != nil { 238 238 + os.Remove(changePath) 239 239 + h.l.Error("pijul apply failed", "hash", hash, "channel", channel, "err", err) 240 240 + http.Error(w, "failed to apply change: "+err.Error(), http.StatusInternalServerError) 241 241 + return 242 242 + } 243 243 + 244 244 + // 5. Get channel state and emit SSE event (best-effort). 245 245 + newState, _ := pr.ChannelState(channel) 246 246 + go h.emitPijulRefUpdate(pusherDid, ownerDid, repoName, repoDid, channel, hash, newState) 247 247 + 248 248 + w.WriteHeader(http.StatusOK) 249 249 + } 250 250 + 251 251 + // pijulTagUp handles POST ?tagup=HASH&to_channel=CHANNEL. 252 252 + // Tags (state snapshots) are saved but not broadcast — they're used for pinning. 253 253 + func (h *Knot) pijulTagUp(w http.ResponseWriter, r *http.Request, repoPath, hash, channel string) { 254 254 + if _, err := parseBearerDID(r); err != nil { 255 255 + http.Error(w, "unauthorized", http.StatusForbidden) 256 256 + return 257 257 + } 258 258 + 259 259 + if len(hash) < 3 { 260 260 + http.Error(w, "invalid tag hash", http.StatusBadRequest) 261 261 + return 262 262 + } 263 263 + tagDir := filepath.Join(repoPath, ".pijul", "tags", hash[:2]) 264 264 + if err := os.MkdirAll(tagDir, 0755); err != nil { 265 265 + http.Error(w, "failed to create tag directory", http.StatusInternalServerError) 266 266 + return 267 267 + } 268 268 + tagPath := filepath.Join(tagDir, hash[2:]+".tag") 269 269 + body, err := io.ReadAll(r.Body) 270 270 + if err != nil { 271 271 + http.Error(w, "failed to read request body", http.StatusBadRequest) 272 272 + return 273 273 + } 274 274 + if err := os.WriteFile(tagPath, body, 0644); err != nil { 275 275 + http.Error(w, "failed to write tag file", http.StatusInternalServerError) 276 276 + return 277 277 + } 278 278 + w.WriteHeader(http.StatusOK) 279 279 + } 280 280 + 281 281 + // emitPijulRefUpdate inserts a PijulRefUpdate event into the knotserver event log, 282 282 + // which is streamed to the appview via the /events WebSocket. 283 283 + func (h *Knot) emitPijulRefUpdate(committerDid, ownerDid, repoName, repoDid, channel, changeHash, newState string) { 284 284 + repoAt := fmt.Sprintf("at://%s/%s/%s", repoDid, tangled.RepoNSID, repoName) 285 285 + 286 286 + record := tangled.PijulRefUpdate{ 287 287 + Repo: repoAt, 288 288 + Channel: channel, 289 289 + Changes: []string{changeHash}, 290 290 + CommitterDid: committerDid, 291 291 + NewState: newState, 292 292 + } 293 293 + 294 294 + eventJson, err := json.Marshal(record) 295 295 + if err != nil { 296 296 + h.l.Error("failed to marshal pijulRefUpdate event", "err", err) 297 297 + return 298 298 + } 299 299 + 300 300 + event := db.Event{ 301 301 + Rkey: TID(), 302 302 + Nsid: tangled.PijulRefUpdateNSID, 303 303 + EventJson: string(eventJson), 304 304 + } 305 305 + 306 306 + if err := h.db.InsertEvent(event, h.n); err != nil { 307 307 + h.l.Error("failed to insert pijulRefUpdate event", "err", err) 308 308 + } 309 309 + } 310 310 + 311 311 + // parseBearerDID extracts the DID from an AT Protocol Bearer JWT in the 312 312 + // Authorization header. It decodes the JWT payload without verifying the 313 313 + // signature — full verification is a future TODO. 314 314 + func parseBearerDID(r *http.Request) (string, error) { 315 315 + auth := strings.TrimSpace(r.Header.Get("Authorization")) 316 316 + token := strings.TrimPrefix(auth, "Bearer ") 317 317 + if token == "" || token == auth { 318 318 + return "", fmt.Errorf("missing Bearer token") 319 319 + } 320 320 + 321 321 + parts := strings.Split(token, ".") 322 322 + if len(parts) != 3 { 323 323 + return "", fmt.Errorf("malformed JWT") 324 324 + } 325 325 + 326 326 + payload, err := base64.RawURLEncoding.DecodeString(parts[1]) 327 327 + if err != nil { 328 328 + return "", fmt.Errorf("invalid JWT payload encoding") 329 329 + } 330 330 + 331 331 + var claims struct { 332 332 + Sub string `json:"sub"` 333 333 + Iss string `json:"iss"` 334 334 + } 335 335 + if err := json.Unmarshal(payload, &claims); err != nil { 336 336 + return "", fmt.Errorf("invalid JWT payload JSON") 337 337 + } 338 338 + 339 339 + // AT Protocol user JWTs use "sub" for the DID. 340 340 + did := claims.Sub 341 341 + if did == "" { 342 342 + did = claims.Iss 343 343 + } 344 344 + if did == "" || !strings.HasPrefix(did, "did:") { 345 345 + return "", fmt.Errorf("JWT does not contain a valid DID") 346 346 + } 347 347 + 348 348 + return did, nil 349 349 + }

+59 -6

knotserver/router.go

reviewed

··· 5 5 "fmt" 6 6 "log/slog" 7 7 "net/http" 8 8 + "path/filepath" 8 9 "strings" 9 10 11 11 + securejoin "github.com/cyphar/filepath-securejoin" 10 12 "github.com/go-chi/chi/v5" 11 13 "tangled.org/core/idresolver" 12 14 "tangled.org/core/jetstream" ··· 81 83 82 84 r.Route("/{did}", func(r chi.Router) { 83 85 r.Use(h.resolveDidRedirect) 84 84 - 85 85 - r.Get("/info/refs", h.InfoRefs) 86 86 - r.Post("/git-upload-archive", h.UploadArchive) 87 87 - r.Post("/git-upload-pack", h.UploadPack) 88 88 - r.Post("/git-receive-pack", h.ReceivePack) 89 89 - 90 86 r.Route("/{name}", func(r chi.Router) { 87 87 + r.Use(h.resolveRepo) 88 88 + // routes for git operations 91 89 r.Get("/info/refs", h.InfoRefs) 92 90 r.Post("/git-upload-archive", h.UploadArchive) 93 91 r.Post("/git-upload-pack", h.UploadPack) 94 92 r.Post("/git-receive-pack", h.ReceivePack) 93 93 + // pijul HTTP remote protocol 94 94 + r.Get("/.pijul", h.PijulHttpGet) 95 95 + r.Post("/.pijul", h.PijulHttpPost) 95 96 }) 96 97 }) 97 98 ··· 148 149 http.Redirect(w, r, newPath, http.StatusTemporaryRedirect) 149 150 }) 150 151 } 152 152 + 153 153 + type ctxRepoPathKey struct{} 154 154 + 155 155 + func repoPathFromcontext(ctx context.Context) (string, bool) { 156 156 + v, ok := ctx.Value(ctxRepoPathKey{}).(string) 157 157 + return v, ok 158 158 + } 159 159 + 160 160 + // resolveRepo is a http middleware that constructs repo path from given did & name pair. 161 161 + // It first tries to resolve via the database (repo DID lookup), then falls back to 162 162 + // the legacy path layout (scanPath/ownerDid/name). 163 163 + func (h *Knot) resolveRepo(next http.Handler) http.Handler { 164 164 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 165 165 + did := chi.URLParam(r, "did") 166 166 + name := chi.URLParam(r, "name") 167 167 + 168 168 + // Try database resolution first (repo DID based path) 169 169 + repoDid, err := h.db.GetRepoDid(did, name) 170 170 + if err == nil { 171 171 + repoPath, _, _, resolveErr := h.db.ResolveRepoDIDOnDisk(h.c.Repo.ScanPath, repoDid) 172 172 + if resolveErr == nil { 173 173 + ctx := context.WithValue(r.Context(), ctxRepoPathKey{}, repoPath) 174 174 + next.ServeHTTP(w, r.WithContext(ctx)) 175 175 + return 176 176 + } 177 177 + } 178 178 + 179 179 + // Fall back to legacy path layout: scanPath/ownerDid/name 180 180 + repoPath, err := securejoin.SecureJoin(h.c.Repo.ScanPath, filepath.Join(did, name)) 181 181 + if err != nil { 182 182 + w.WriteHeader(http.StatusNotFound) 183 183 + w.Write([]byte("Repository not found")) 184 184 + return 185 185 + } 186 186 + 187 187 + exist, err := isDir(repoPath) 188 188 + if err != nil { 189 189 + w.WriteHeader(http.StatusInternalServerError) 190 190 + w.Write([]byte("Failed to check repository path")) 191 191 + return 192 192 + } 193 193 + if !exist { 194 194 + w.WriteHeader(http.StatusNotFound) 195 195 + w.Write([]byte("Repository not found")) 196 196 + return 197 197 + } 198 198 + 199 199 + ctx := context.WithValue(r.Context(), ctxRepoPathKey{}, repoPath) 200 200 + next.ServeHTTP(w, r.WithContext(ctx)) 201 201 + }) 202 202 + } 203 203 + 151 204 152 205 func (h *Knot) configureOwner() error { 153 206 cfgOwner := h.c.Server.Owner

+75

knotserver/vcs/backend.go

reviewed

··· 1 1 + package vcs 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "errors" 6 6 + "io" 7 7 + 8 8 + "tangled.org/core/knotserver/git" 9 9 + "tangled.org/core/knotserver/pijul" 10 10 + ) 11 11 + 12 12 + // ErrBinaryFile is returned by FileContentN when the file appears to be binary. 13 13 + // It matches both git.ErrBinaryFile and pijul.ErrBinaryFile. 14 14 + var ErrBinaryFile = errors.New("binary file") 15 15 + 16 16 + // IsBinaryFileError returns true if the error indicates a binary file, 17 17 + // matching against both the vcs, git, and pijul error types. 18 18 + func IsBinaryFileError(err error) bool { 19 19 + return errors.Is(err, ErrBinaryFile) || 20 20 + errors.Is(err, git.ErrBinaryFile) || 21 21 + errors.Is(err, pijul.ErrBinaryFile) 22 22 + } 23 23 + 24 24 + // ReadRepo provides read-only access to a VCS repository, abstracting 25 25 + // over git and pijul. 26 26 + type ReadRepo interface { 27 27 + // VCSType returns "git" or "pijul". 28 28 + VCSType() string 29 29 + 30 30 + // Path returns the on-disk path of the repository. 31 31 + Path() string 32 32 + 33 33 + // History returns history entries (commits/changes) with pagination. 34 34 + History(offset, limit int) ([]HistoryEntry, error) 35 35 + 36 36 + // TotalHistoryEntries returns the total count of commits/changes. 37 37 + TotalHistoryEntries() (int, error) 38 38 + 39 39 + // HistoryEntry returns a single commit/change by hash. 40 40 + HistoryEntry(hash string) (*HistoryEntry, error) 41 41 + 42 42 + // Branches returns branches/channels with optional pagination. 43 43 + Branches(opts *PaginationOpts) ([]BranchInfo, error) 44 44 + 45 45 + // DefaultBranch returns the name of the default branch/channel. 46 46 + DefaultBranch() (string, error) 47 47 + 48 48 + // FileTree returns the directory listing at the given path. 49 49 + FileTree(ctx context.Context, path string) ([]TreeEntry, error) 50 50 + 51 51 + // FileContentN reads up to cap bytes of a file, returning ErrBinaryFile 52 52 + // if the file appears to be binary. 53 53 + FileContentN(path string, cap int64) ([]byte, error) 54 54 + 55 55 + // RawContent reads the full raw content of a file. 56 56 + RawContent(path string) ([]byte, error) 57 57 + 58 58 + // WriteTar writes a tar archive of the repository to w, prefixing 59 59 + // all paths with prefix. 60 60 + WriteTar(w io.Writer, prefix string) error 61 61 + 62 62 + // Tags returns tags with optional pagination. Pijul repos return nil. 63 63 + Tags(opts *PaginationOpts) ([]TagInfo, error) 64 64 + } 65 65 + 66 66 + // MutableRepo extends ReadRepo with write operations. 67 67 + type MutableRepo interface { 68 68 + ReadRepo 69 69 + 70 70 + // SetDefaultBranch sets the default branch/channel. 71 71 + SetDefaultBranch(name string) error 72 72 + 73 73 + // DeleteBranch deletes a branch/channel. 74 74 + DeleteBranch(name string) error 75 75 + }

+40

knotserver/vcs/detect.go

reviewed

··· 1 1 + package vcs 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "os" 6 6 + "path/filepath" 7 7 + ) 8 8 + 9 9 + // IsPijulRepo checks if the given path contains a Pijul repository. 10 10 + func IsPijulRepo(path string) bool { 11 11 + info, err := os.Stat(filepath.Join(path, ".pijul")) 12 12 + if err != nil { 13 13 + return false 14 14 + } 15 15 + return info.IsDir() 16 16 + } 17 17 + 18 18 + // IsGitRepo checks if the given path contains a Git repository. 19 19 + func IsGitRepo(path string) bool { 20 20 + info, err := os.Stat(filepath.Join(path, ".git")) 21 21 + if err != nil { 22 22 + // Also check for bare git repos (HEAD file at top level). 23 23 + if _, err := os.Stat(filepath.Join(path, "HEAD")); err == nil { 24 24 + return true 25 25 + } 26 26 + return false 27 27 + } 28 28 + return info.IsDir() 29 29 + } 30 30 + 31 31 + // DetectVCS detects whether a path contains a Git or Pijul repository. 32 32 + func DetectVCS(path string) (string, error) { 33 33 + if IsPijulRepo(path) { 34 34 + return "pijul", nil 35 35 + } 36 36 + if IsGitRepo(path) { 37 37 + return "git", nil 38 38 + } 39 39 + return "", fmt.Errorf("no VCS repository found at %s", path) 40 40 + }

+226

knotserver/vcs/gitadapter.go

reviewed

··· 1 1 + package vcs 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "io" 6 6 + 7 7 + "tangled.org/core/knotserver/git" 8 8 + ) 9 9 + 10 10 + // gitReadAdapter wraps a git.GitRepo to implement ReadRepo. 11 11 + type gitReadAdapter struct { 12 12 + g *git.GitRepo 13 13 + } 14 14 + 15 15 + func newGitReadAdapter(g *git.GitRepo) *gitReadAdapter { 16 16 + return &gitReadAdapter{g: g} 17 17 + } 18 18 + 19 19 + func (a *gitReadAdapter) VCSType() string { return "git" } 20 20 + func (a *gitReadAdapter) Path() string { return a.g.Path() } 21 21 + 22 22 + func (a *gitReadAdapter) History(offset, limit int) ([]HistoryEntry, error) { 23 23 + commits, err := a.g.Commits(offset, limit) 24 24 + if err != nil { 25 25 + return nil, err 26 26 + } 27 27 + 28 28 + entries := make([]HistoryEntry, 0, len(commits)) 29 29 + for _, c := range commits { 30 30 + parents := make([]string, 0, len(c.ParentHashes)) 31 31 + for _, p := range c.ParentHashes { 32 32 + parents = append(parents, p.String()) 33 33 + } 34 34 + entries = append(entries, HistoryEntry{ 35 35 + Hash: c.Hash.String(), 36 36 + Author: Author{ 37 37 + Name: c.Author.Name, 38 38 + Email: c.Author.Email, 39 39 + When: c.Author.When, 40 40 + }, 41 41 + Committer: Author{ 42 42 + Name: c.Committer.Name, 43 43 + Email: c.Committer.Email, 44 44 + When: c.Committer.When, 45 45 + }, 46 46 + Message: c.Message, 47 47 + Timestamp: c.Committer.When, 48 48 + Parents: parents, 49 49 + }) 50 50 + } 51 51 + return entries, nil 52 52 + } 53 53 + 54 54 + func (a *gitReadAdapter) TotalHistoryEntries() (int, error) { 55 55 + return a.g.TotalCommits() 56 56 + } 57 57 + 58 58 + func (a *gitReadAdapter) HistoryEntry(hash string) (*HistoryEntry, error) { 59 59 + c, err := a.g.Commit(gitHash(hash)) 60 60 + if err != nil { 61 61 + return nil, err 62 62 + } 63 63 + 64 64 + parents := make([]string, 0, len(c.ParentHashes)) 65 65 + for _, p := range c.ParentHashes { 66 66 + parents = append(parents, p.String()) 67 67 + } 68 68 + 69 69 + return &HistoryEntry{ 70 70 + Hash: c.Hash.String(), 71 71 + Author: Author{ 72 72 + Name: c.Author.Name, 73 73 + Email: c.Author.Email, 74 74 + When: c.Author.When, 75 75 + }, 76 76 + Committer: Author{ 77 77 + Name: c.Committer.Name, 78 78 + Email: c.Committer.Email, 79 79 + When: c.Committer.When, 80 80 + }, 81 81 + Message: c.Message, 82 82 + Timestamp: c.Committer.When, 83 83 + Parents: parents, 84 84 + }, nil 85 85 + } 86 86 + 87 87 + func (a *gitReadAdapter) Branches(opts *PaginationOpts) ([]BranchInfo, error) { 88 88 + var gitOpts *git.BranchesOptions 89 89 + if opts != nil { 90 90 + gitOpts = &git.BranchesOptions{ 91 91 + Limit: opts.Limit, 92 92 + Offset: opts.Offset, 93 93 + } 94 94 + } 95 95 + 96 96 + branches, err := a.g.Branches(gitOpts) 97 97 + if err != nil { 98 98 + return nil, err 99 99 + } 100 100 + 101 101 + infos := make([]BranchInfo, 0, len(branches)) 102 102 + for _, b := range branches { 103 103 + info := BranchInfo{ 104 104 + Name: b.Name, 105 105 + Hash: b.Hash, 106 106 + IsDefault: b.IsDefault, 107 107 + } 108 108 + if b.Commit != nil { 109 109 + info.LatestEntry = &HistoryEntry{ 110 110 + Hash: b.Commit.Hash.String(), 111 111 + Author: Author{ 112 112 + Name: b.Commit.Author.Name, 113 113 + Email: b.Commit.Author.Email, 114 114 + When: b.Commit.Author.When, 115 115 + }, 116 116 + Committer: Author{ 117 117 + Name: b.Commit.Committer.Name, 118 118 + Email: b.Commit.Committer.Email, 119 119 + When: b.Commit.Committer.When, 120 120 + }, 121 121 + Message: b.Commit.Message, 122 122 + Timestamp: b.Commit.Committer.When, 123 123 + } 124 124 + } 125 125 + infos = append(infos, info) 126 126 + } 127 127 + return infos, nil 128 128 + } 129 129 + 130 130 + func (a *gitReadAdapter) DefaultBranch() (string, error) { 131 131 + return a.g.FindMainBranch() 132 132 + } 133 133 + 134 134 + func (a *gitReadAdapter) FileTree(ctx context.Context, path string) ([]TreeEntry, error) { 135 135 + files, err := a.g.FileTree(ctx, path) 136 136 + if err != nil { 137 137 + return nil, err 138 138 + } 139 139 + 140 140 + entries := make([]TreeEntry, 0, len(files)) 141 141 + for _, f := range files { 142 142 + entry := TreeEntry{ 143 143 + Name: f.Name, 144 144 + Mode: f.Mode, 145 145 + Size: f.Size, 146 146 + } 147 147 + if f.LastCommit != nil { 148 148 + entry.LastCommit = &LastCommitInfo{ 149 149 + Hash: f.LastCommit.Hash.String(), 150 150 + Message: f.LastCommit.Message, 151 151 + When: f.LastCommit.When, 152 152 + } 153 153 + } 154 154 + entries = append(entries, entry) 155 155 + } 156 156 + return entries, nil 157 157 + } 158 158 + 159 159 + func (a *gitReadAdapter) FileContentN(path string, cap int64) ([]byte, error) { 160 160 + return a.g.FileContentN(path, cap) 161 161 + } 162 162 + 163 163 + func (a *gitReadAdapter) RawContent(path string) ([]byte, error) { 164 164 + return a.g.RawContent(path) 165 165 + } 166 166 + 167 167 + func (a *gitReadAdapter) WriteTar(w io.Writer, prefix string) error { 168 168 + return a.g.WriteTar(w, prefix) 169 169 + } 170 170 + 171 171 + func (a *gitReadAdapter) Tags(opts *PaginationOpts) ([]TagInfo, error) { 172 172 + var gitOpts *git.TagsOptions 173 173 + if opts != nil { 174 174 + gitOpts = &git.TagsOptions{ 175 175 + Limit: opts.Limit, 176 176 + Offset: opts.Offset, 177 177 + } 178 178 + } 179 179 + 180 180 + tags, err := a.g.Tags(gitOpts) 181 181 + if err != nil { 182 182 + return nil, err 183 183 + } 184 184 + 185 185 + infos := make([]TagInfo, 0, len(tags)) 186 186 + for _, t := range tags { 187 187 + info := TagInfo{ 188 188 + Name: t.Name, 189 189 + Hash: t.Hash.String(), 190 190 + Message: t.Message, 191 191 + Target: t.Target.String(), 192 192 + } 193 193 + if t.Tagger.Name != "" { 194 194 + info.Tagger = &Author{ 195 195 + Name: t.Tagger.Name, 196 196 + Email: t.Tagger.Email, 197 197 + When: t.Tagger.When, 198 198 + } 199 199 + } 200 200 + infos = append(infos, info) 201 201 + } 202 202 + return infos, nil 203 203 + } 204 204 + 205 205 + // gitMutableAdapter wraps a git.GitRepo to implement MutableRepo. 206 206 + type gitMutableAdapter struct { 207 207 + *gitReadAdapter 208 208 + } 209 209 + 210 210 + func newGitMutableAdapter(g *git.GitRepo) *gitMutableAdapter { 211 211 + return &gitMutableAdapter{gitReadAdapter: newGitReadAdapter(g)} 212 212 + } 213 213 + 214 214 + func (a *gitMutableAdapter) SetDefaultBranch(name string) error { 215 215 + return a.g.SetDefaultBranch(name) 216 216 + } 217 217 + 218 218 + func (a *gitMutableAdapter) DeleteBranch(name string) error { 219 219 + return a.g.DeleteBranch(name) 220 220 + } 221 221 + 222 222 + // Git returns the underlying *git.GitRepo for git-specific operations 223 223 + // (diff, merge, format-patch, etc.) that don't belong in the VCS interface. 224 224 + func (a *gitReadAdapter) Git() *git.GitRepo { 225 225 + return a.g 226 226 + }

+91

knotserver/vcs/open.go

reviewed

··· 1 1 + package vcs 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + 6 6 + "github.com/go-git/go-git/v5/plumbing" 7 7 + "tangled.org/core/knotserver/git" 8 8 + "tangled.org/core/knotserver/pijul" 9 9 + ) 10 10 + 11 11 + // Open opens a repository at path with the given ref (branch/tag/hash). 12 12 + // It auto-detects the VCS type and returns the appropriate adapter. 13 13 + // For git, ref is resolved as a revision; for pijul, ref is the channel name. 14 14 + func Open(path, ref string) (ReadRepo, error) { 15 15 + vcsType, err := DetectVCS(path) 16 16 + if err != nil { 17 17 + return nil, err 18 18 + } 19 19 + 20 20 + switch vcsType { 21 21 + case "git": 22 22 + g, err := git.Open(path, ref) 23 23 + if err != nil { 24 24 + return nil, err 25 25 + } 26 26 + return newGitReadAdapter(g), nil 27 27 + case "pijul": 28 28 + p, err := pijul.Open(path, ref) 29 29 + if err != nil { 30 30 + return nil, err 31 31 + } 32 32 + return newPijulReadAdapter(p), nil 33 33 + default: 34 34 + return nil, fmt.Errorf("unsupported VCS type: %s", vcsType) 35 35 + } 36 36 + } 37 37 + 38 38 + // PlainOpen opens a repository at path without setting a specific ref. 39 39 + // Returns a MutableRepo since no ref is pinned. 40 40 + func PlainOpen(path string) (MutableRepo, error) { 41 41 + vcsType, err := DetectVCS(path) 42 42 + if err != nil { 43 43 + return nil, err 44 44 + } 45 45 + 46 46 + switch vcsType { 47 47 + case "git": 48 48 + g, err := git.PlainOpen(path) 49 49 + if err != nil { 50 50 + return nil, err 51 51 + } 52 52 + return newGitMutableAdapter(g), nil 53 53 + case "pijul": 54 54 + p, err := pijul.PlainOpen(path) 55 55 + if err != nil { 56 56 + return nil, err 57 57 + } 58 58 + return newPijulMutableAdapter(p), nil 59 59 + default: 60 60 + return nil, fmt.Errorf("unsupported VCS type: %s", vcsType) 61 61 + } 62 62 + } 63 63 + 64 64 + // AsGit returns the underlying *git.GitRepo if repo is a git adapter, or nil. 65 65 + // Use this for git-specific operations that don't belong in the VCS interface. 66 66 + func AsGit(repo ReadRepo) *git.GitRepo { 67 67 + switch r := repo.(type) { 68 68 + case *gitReadAdapter: 69 69 + return r.Git() 70 70 + case *gitMutableAdapter: 71 71 + return r.Git() 72 72 + } 73 73 + return nil 74 74 + } 75 75 + 76 76 + // AsPijul returns the underlying *pijul.PijulRepo if repo is a pijul adapter, or nil. 77 77 + // Use this for pijul-specific operations that don't belong in the VCS interface. 78 78 + func AsPijul(repo ReadRepo) *pijul.PijulRepo { 79 79 + switch r := repo.(type) { 80 80 + case *pijulReadAdapter: 81 81 + return r.Pijul() 82 82 + case *pijulMutableAdapter: 83 83 + return r.Pijul() 84 84 + } 85 85 + return nil 86 86 + } 87 87 + 88 88 + // gitHash converts a hex string to a plumbing.Hash. 89 89 + func gitHash(s string) plumbing.Hash { 90 90 + return plumbing.NewHash(s) 91 91 + }

+180

knotserver/vcs/pijuladapter.go

reviewed

··· 1 1 + package vcs 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "io" 6 6 + 7 7 + "tangled.org/core/knotserver/pijul" 8 8 + ) 9 9 + 10 10 + // pijulReadAdapter wraps a pijul.PijulRepo to implement ReadRepo. 11 11 + type pijulReadAdapter struct { 12 12 + p *pijul.PijulRepo 13 13 + } 14 14 + 15 15 + func newPijulReadAdapter(p *pijul.PijulRepo) *pijulReadAdapter { 16 16 + return &pijulReadAdapter{p: p} 17 17 + } 18 18 + 19 19 + func (a *pijulReadAdapter) VCSType() string { return "pijul" } 20 20 + func (a *pijulReadAdapter) Path() string { return a.p.Path() } 21 21 + 22 22 + func (a *pijulReadAdapter) History(offset, limit int) ([]HistoryEntry, error) { 23 23 + changes, err := a.p.Changes(offset, limit) 24 24 + if err != nil { 25 25 + return nil, err 26 26 + } 27 27 + 28 28 + entries := make([]HistoryEntry, 0, len(changes)) 29 29 + for _, c := range changes { 30 30 + var author Author 31 31 + if len(c.Authors) > 0 { 32 32 + author = Author{ 33 33 + Name: c.Authors[0].Name, 34 34 + Email: c.Authors[0].Email, 35 35 + DID: c.Authors[0].DID, 36 36 + } 37 37 + } 38 38 + entries = append(entries, HistoryEntry{ 39 39 + Hash: c.Hash, 40 40 + Author: author, 41 41 + Committer: author, 42 42 + Message: c.Message, 43 43 + Timestamp: c.Timestamp, 44 44 + Parents: c.Dependencies, 45 45 + }) 46 46 + } 47 47 + return entries, nil 48 48 + } 49 49 + 50 50 + func (a *pijulReadAdapter) TotalHistoryEntries() (int, error) { 51 51 + return a.p.TotalChanges() 52 52 + } 53 53 + 54 54 + func (a *pijulReadAdapter) HistoryEntry(hash string) (*HistoryEntry, error) { 55 55 + c, err := a.p.GetChange(hash) 56 56 + if err != nil { 57 57 + return nil, err 58 58 + } 59 59 + 60 60 + var author Author 61 61 + if len(c.Authors) > 0 { 62 62 + author = Author{ 63 63 + Name: c.Authors[0].Name, 64 64 + Email: c.Authors[0].Email, 65 65 + DID: c.Authors[0].DID, 66 66 + } 67 67 + } 68 68 + 69 69 + return &HistoryEntry{ 70 70 + Hash: c.Hash, 71 71 + Author: author, 72 72 + Committer: author, 73 73 + Message: c.Message, 74 74 + Timestamp: c.Timestamp, 75 75 + Parents: c.Dependencies, 76 76 + }, nil 77 77 + } 78 78 + 79 79 + func (a *pijulReadAdapter) Branches(opts *PaginationOpts) ([]BranchInfo, error) { 80 80 + var pijulOpts *pijul.ChannelOptions 81 81 + if opts != nil { 82 82 + pijulOpts = &pijul.ChannelOptions{ 83 83 + Limit: opts.Limit, 84 84 + Offset: opts.Offset, 85 85 + } 86 86 + } 87 87 + 88 88 + channels, err := a.p.ChannelsWithOptions(pijulOpts) 89 89 + if err != nil { 90 90 + return nil, err 91 91 + } 92 92 + 93 93 + infos := make([]BranchInfo, 0, len(channels)) 94 94 + for _, ch := range channels { 95 95 + info := BranchInfo{ 96 96 + Name: ch.Name, 97 97 + IsDefault: ch.IsCurrent, 98 98 + } 99 99 + if latest, err := a.p.LatestChangeInChannel(ch.Name); err == nil && latest != nil { 100 100 + info.Hash = latest.Hash 101 101 + entry := &HistoryEntry{ 102 102 + Hash: latest.Hash, 103 103 + Message: latest.Message, 104 104 + Timestamp: latest.Timestamp, 105 105 + } 106 106 + if len(latest.Authors) > 0 { 107 107 + entry.Author = Author{ 108 108 + Name: latest.Authors[0].Name, 109 109 + Email: latest.Authors[0].Email, 110 110 + DID: latest.Authors[0].DID, 111 111 + } 112 112 + entry.Committer = entry.Author 113 113 + } 114 114 + info.LatestEntry = entry 115 115 + } 116 116 + infos = append(infos, info) 117 117 + } 118 118 + return infos, nil 119 119 + } 120 120 + 121 121 + func (a *pijulReadAdapter) DefaultBranch() (string, error) { 122 122 + return a.p.FindDefaultChannel() 123 123 + } 124 124 + 125 125 + func (a *pijulReadAdapter) FileTree(ctx context.Context, path string) ([]TreeEntry, error) { 126 126 + files, err := a.p.FileTree(ctx, path) 127 127 + if err != nil { 128 128 + return nil, err 129 129 + } 130 130 + 131 131 + entries := make([]TreeEntry, 0, len(files)) 132 132 + for _, f := range files { 133 133 + entries = append(entries, TreeEntry{ 134 134 + Name: f.Name, 135 135 + Mode: f.Mode, 136 136 + Size: f.Size, 137 137 + }) 138 138 + } 139 139 + return entries, nil 140 140 + } 141 141 + 142 142 + func (a *pijulReadAdapter) FileContentN(path string, cap int64) ([]byte, error) { 143 143 + return a.p.FileContentN(path, cap) 144 144 + } 145 145 + 146 146 + func (a *pijulReadAdapter) RawContent(path string) ([]byte, error) { 147 147 + return a.p.RawContent(path) 148 148 + } 149 149 + 150 150 + func (a *pijulReadAdapter) WriteTar(w io.Writer, prefix string) error { 151 151 + return a.p.WriteTar(w, prefix) 152 152 + } 153 153 + 154 154 + func (a *pijulReadAdapter) Tags(_ *PaginationOpts) ([]TagInfo, error) { 155 155 + // Pijul doesn't have tags. 156 156 + return nil, nil 157 157 + } 158 158 + 159 159 + // pijulMutableAdapter wraps a pijul.PijulRepo to implement MutableRepo. 160 160 + type pijulMutableAdapter struct { 161 161 + *pijulReadAdapter 162 162 + } 163 163 + 164 164 + func newPijulMutableAdapter(p *pijul.PijulRepo) *pijulMutableAdapter { 165 165 + return &pijulMutableAdapter{pijulReadAdapter: newPijulReadAdapter(p)} 166 166 + } 167 167 + 168 168 + func (a *pijulMutableAdapter) SetDefaultBranch(name string) error { 169 169 + return a.p.SetDefaultChannel(name) 170 170 + } 171 171 + 172 172 + func (a *pijulMutableAdapter) DeleteBranch(name string) error { 173 173 + return a.p.DeleteChannel(name) 174 174 + } 175 175 + 176 176 + // Pijul returns the underlying *pijul.PijulRepo for pijul-specific operations 177 177 + // that don't belong in the VCS interface. 178 178 + func (a *pijulReadAdapter) Pijul() *pijul.PijulRepo { 179 179 + return a.p 180 180 + }

+65

knotserver/vcs/types.go

reviewed

··· 1 1 + package vcs 2 2 + 3 3 + import "time" 4 4 + 5 5 + // Author represents a commit/change author. 6 6 + type Author struct { 7 7 + Name string 8 8 + Email string 9 9 + When time.Time 10 10 + // DID is the AT Protocol decentralized identifier of the author. 11 11 + // Populated for pijul changes that carry identity metadata. 12 12 + DID string 13 13 + } 14 14 + 15 15 + // HistoryEntry is a VCS-agnostic representation of a commit or change. 16 16 + type HistoryEntry struct { 17 17 + Hash string 18 18 + Author Author 19 19 + Committer Author 20 20 + Message string 21 21 + Timestamp time.Time 22 22 + // Parents lists parent hashes (git) or dependency hashes (pijul). 23 23 + Parents []string 24 24 + } 25 25 + 26 26 + // BranchInfo is a VCS-agnostic branch/channel. 27 27 + type BranchInfo struct { 28 28 + Name string 29 29 + Hash string 30 30 + IsDefault bool 31 31 + // LatestEntry is the most recent commit/change on this branch, if available. 32 32 + LatestEntry *HistoryEntry 33 33 + } 34 34 + 35 35 + // TreeEntry is a VCS-agnostic file/directory entry. 36 36 + type TreeEntry struct { 37 37 + Name string 38 38 + Mode string 39 39 + Size int64 40 40 + LastCommit *LastCommitInfo 41 41 + } 42 42 + 43 43 + // LastCommitInfo holds metadata about the last commit that touched a file. 44 44 + type LastCommitInfo struct { 45 45 + Hash string 46 46 + Message string 47 47 + When time.Time 48 48 + Author *Author 49 49 + } 50 50 + 51 51 + // TagInfo is a VCS-agnostic tag. 52 52 + type TagInfo struct { 53 53 + Name string 54 54 + Hash string 55 55 + Message string 56 56 + Tagger *Author 57 57 + // Target is the hash of the tagged object (for annotated tags). 58 58 + Target string 59 59 + } 60 60 + 61 61 + // PaginationOpts controls pagination for list operations. 62 62 + type PaginationOpts struct { 63 63 + Offset int 64 64 + Limit int 65 65 + }

+22 -3

knotserver/xrpc/create_repo.go

reviewed

··· 17 17 "tangled.org/core/api/tangled" 18 18 "tangled.org/core/hook" 19 19 "tangled.org/core/knotserver/git" 20 20 + "tangled.org/core/knotserver/pijul" 20 21 "tangled.org/core/knotserver/repodid" 21 22 "tangled.org/core/rbac" 22 23 xrpcerr "tangled.org/core/xrpc/errors" ··· 52 53 } 53 54 54 55 repoName := data.Name 56 56 + 57 57 + vcs := "git" 58 58 + if data.Vcs != nil && strings.TrimSpace(*data.Vcs) != "" { 59 59 + vcs = strings.ToLower(strings.TrimSpace(*data.Vcs)) 60 60 + } 61 61 + switch vcs { 62 62 + case "git", "pijul": 63 63 + default: 64 64 + fail(xrpcerr.GenericError(fmt.Errorf("unsupported vcs: %s", vcs))) 65 65 + return 66 66 + } 55 67 56 68 if repoName == "" { 57 69 fail(xrpcerr.GenericError(fmt.Errorf("repository name is required"))) ··· 160 172 } 161 173 162 174 if data.Source != nil && *data.Source != "" { 163 163 - err = git.Fork(repoPath, *data.Source, h.Config) 175 175 + if vcs == "pijul" { 176 176 + err = pijul.Clone(*data.Source, repoPath, "") 177 177 + } else { 178 178 + err = git.Fork(repoPath, *data.Source, h.Config) 179 179 + } 164 180 if err != nil { 165 181 l.Error("forking repo", "error", err.Error()) 166 182 cleanupAll() ··· 168 184 return 169 185 } 170 186 } else { 171 171 - err = git.InitBare(repoPath, defaultBranch) 187 187 + if vcs == "pijul" { 188 188 + err = pijul.InitBare(repoPath) 189 189 + } else { 190 190 + err = git.InitBare(repoPath, defaultBranch) 191 191 + } 172 192 if err != nil { 173 193 l.Error("initializing bare repo", "error", err.Error()) 174 194 cleanupAll() ··· 214 234 writeError(w, xrpcerr.GenericError(err), http.StatusInternalServerError) 215 235 return 216 236 } 217 217 - 218 237 hook.SetupRepo( 219 238 hook.Config( 220 239 hook.WithScanPath(h.Config.Repo.ScanPath),

+168

knotserver/xrpc/pijul_apply.go

reviewed

··· 1 1 + package xrpc 2 2 + 3 3 + import ( 4 4 + "encoding/json" 5 5 + "net/http" 6 6 + "strings" 7 7 + 8 8 + "github.com/bluesky-social/indigo/atproto/syntax" 9 9 + "tangled.org/core/knotserver/pijul" 10 10 + "tangled.org/core/rbac" 11 11 + xrpcerr "tangled.org/core/xrpc/errors" 12 12 + ) 13 13 + 14 14 + // ApplyChangesRequest is the request body for applying changes 15 15 + type ApplyChangesRequest struct { 16 16 + Repo string `json:"repo"` 17 17 + Channel string `json:"channel"` 18 18 + Changes []string `json:"changes"` 19 19 + } 20 20 + 21 21 + // ApplyChangesResponse is the response for applying changes 22 22 + type ApplyChangesResponse struct { 23 23 + Applied []string `json:"applied"` 24 24 + Failed []ApplyChangeFailure `json:"failed,omitempty"` 25 25 + NewState string `json:"newState,omitempty"` 26 26 + } 27 27 + 28 28 + // ApplyChangeFailure represents a failed change application 29 29 + type ApplyChangeFailure struct { 30 30 + Hash string `json:"hash"` 31 31 + Error string `json:"error"` 32 32 + } 33 33 + 34 34 + // RepoApplyChanges handles the sh.tangled.repo.applyChanges endpoint 35 35 + // Applies Pijul changes to a repository channel (used for merging discussions) 36 36 + func (x *Xrpc) RepoApplyChanges(w http.ResponseWriter, r *http.Request) { 37 37 + if r.Method != http.MethodPost { 38 38 + writeError(w, xrpcerr.NewXrpcError( 39 39 + xrpcerr.WithTag("InvalidRequest"), 40 40 + xrpcerr.WithMessage("method not allowed"), 41 41 + ), http.StatusMethodNotAllowed) 42 42 + return 43 43 + } 44 44 + 45 45 + var req ApplyChangesRequest 46 46 + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { 47 47 + writeError(w, xrpcerr.NewXrpcError( 48 48 + xrpcerr.WithTag("InvalidRequest"), 49 49 + xrpcerr.WithMessage("invalid request body"), 50 50 + ), http.StatusBadRequest) 51 51 + return 52 52 + } 53 53 + 54 54 + if req.Repo == "" || req.Channel == "" || len(req.Changes) == 0 { 55 55 + writeError(w, xrpcerr.NewXrpcError( 56 56 + xrpcerr.WithTag("InvalidRequest"), 57 57 + xrpcerr.WithMessage("repo, channel, and changes are required"), 58 58 + ), http.StatusBadRequest) 59 59 + return 60 60 + } 61 61 + 62 62 + // Authorization: verify the caller has push permission 63 63 + actorDid, ok := r.Context().Value(ActorDid).(syntax.DID) 64 64 + if !ok { 65 65 + writeError(w, xrpcerr.MissingActorDidError, http.StatusBadRequest) 66 66 + return 67 67 + } 68 68 + 69 69 + repoPath, err := x.parseRepoParam(req.Repo) 70 70 + if err != nil { 71 71 + writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest) 72 72 + return 73 73 + } 74 74 + 75 75 + repoParts := strings.SplitN(req.Repo, "/", 2) 76 76 + if len(repoParts) != 2 { 77 77 + writeError(w, xrpcerr.NewXrpcError( 78 78 + xrpcerr.WithTag("InvalidRequest"), 79 79 + xrpcerr.WithMessage("invalid repo format"), 80 80 + ), http.StatusBadRequest) 81 81 + return 82 82 + } 83 83 + repoDid, dbErr := x.Db.GetRepoDid(repoParts[0], repoParts[1]) 84 84 + if dbErr != nil { 85 85 + repoDid = repoParts[0] + "/" + repoParts[1] 86 86 + } 87 87 + pushOk, err := x.Enforcer.IsPushAllowed(actorDid.String(), rbac.ThisServer, repoDid) 88 88 + if err != nil || !pushOk { 89 89 + writeError(w, xrpcerr.NewXrpcError( 90 90 + xrpcerr.WithTag("Forbidden"), 91 91 + xrpcerr.WithMessage("push permission required to apply changes"), 92 92 + ), http.StatusForbidden) 93 93 + return 94 94 + } 95 95 + 96 96 + // Open the repository with the target channel 97 97 + pr, err := pijul.Open(repoPath, req.Channel) 98 98 + if err != nil { 99 99 + writeError(w, xrpcerr.NewXrpcError( 100 100 + xrpcerr.WithTag("RepoNotFound"), 101 101 + xrpcerr.WithMessage("failed to open pijul repository"), 102 102 + ), http.StatusNotFound) 103 103 + return 104 104 + } 105 105 + 106 106 + // Verify the channel exists 107 107 + channels, err := pr.Channels() 108 108 + if err != nil { 109 109 + writeError(w, xrpcerr.NewXrpcError( 110 110 + xrpcerr.WithTag("InternalServerError"), 111 111 + xrpcerr.WithMessage("failed to list channels"), 112 112 + ), http.StatusInternalServerError) 113 113 + return 114 114 + } 115 115 + 116 116 + channelExists := false 117 117 + for _, ch := range channels { 118 118 + if ch.Name == req.Channel { 119 119 + channelExists = true 120 120 + break 121 121 + } 122 122 + } 123 123 + 124 124 + if !channelExists { 125 125 + writeError(w, xrpcerr.NewXrpcError( 126 126 + xrpcerr.WithTag("ChannelNotFound"), 127 127 + xrpcerr.WithMessage("target channel not found"), 128 128 + ), http.StatusNotFound) 129 129 + return 130 130 + } 131 131 + 132 132 + // Apply each change in order 133 133 + response := ApplyChangesResponse{ 134 134 + Applied: make([]string, 0), 135 135 + Failed: make([]ApplyChangeFailure, 0), 136 136 + } 137 137 + 138 138 + for _, changeHash := range req.Changes { 139 139 + if err := pr.Apply(changeHash); err != nil { 140 140 + x.Logger.Error("failed to apply change", "hash", changeHash, "error", err.Error()) 141 141 + response.Failed = append(response.Failed, ApplyChangeFailure{ 142 142 + Hash: changeHash, 143 143 + Error: err.Error(), 144 144 + }) 145 145 + } else { 146 146 + response.Applied = append(response.Applied, changeHash) 147 147 + x.Logger.Info("applied change", "hash", changeHash, "channel", req.Channel) 148 148 + } 149 149 + } 150 150 + 151 151 + // If any changes failed, return partial success 152 152 + if len(response.Failed) > 0 && len(response.Applied) == 0 { 153 153 + writeError(w, xrpcerr.NewXrpcError( 154 154 + xrpcerr.WithTag("ApplyFailed"), 155 155 + xrpcerr.WithMessage("all changes failed to apply"), 156 156 + ), http.StatusInternalServerError) 157 157 + return 158 158 + } 159 159 + 160 160 + // Populate the channel's Merkle state after applying (best-effort). 161 161 + if state, err := pr.ChannelState(req.Channel); err != nil { 162 162 + x.Logger.Warn("failed to get channel state after apply", "channel", req.Channel, "error", err) 163 163 + } else { 164 164 + response.NewState = state 165 165 + } 166 166 + 167 167 + writeJson(w, response) 168 168 + }

+219

knotserver/xrpc/pijul_changes.go

reviewed

··· 1 1 + package xrpc 2 2 + 3 3 + import ( 4 4 + "net/http" 5 5 + "strconv" 6 6 + "time" 7 7 + 8 8 + "tangled.org/core/knotserver/vcs" 9 9 + xrpcerr "tangled.org/core/xrpc/errors" 10 10 + ) 11 11 + 12 12 + // PijulChangeListResponse is the response for listing Pijul changes 13 13 + type PijulChangeListResponse struct { 14 14 + Changes []PijulChangeEntry `json:"changes"` 15 15 + Channel string `json:"channel,omitempty"` 16 16 + Page int `json:"page"` 17 17 + PerPage int `json:"per_page"` 18 18 + Total int `json:"total"` 19 19 + } 20 20 + 21 21 + // PijulChangeEntry represents a single change in the list 22 22 + type PijulChangeEntry struct { 23 23 + Hash string `json:"hash"` 24 24 + Authors []PijulAuthor `json:"authors"` 25 25 + Message string `json:"message"` 26 26 + Timestamp string `json:"timestamp,omitempty"` 27 27 + Dependencies []string `json:"dependencies,omitempty"` 28 28 + } 29 29 + 30 30 + // PijulAuthor represents a change author 31 31 + type PijulAuthor struct { 32 32 + Name string `json:"name"` 33 33 + Email string `json:"email,omitempty"` 34 34 + Did string `json:"did,omitempty"` 35 35 + } 36 36 + 37 37 + // RepoChangeList handles the sh.tangled.repo.changeList endpoint 38 38 + // Lists changes (Pijul equivalent of commits) in a repository. 39 39 + // Uses the unified VCS History interface. 40 40 + func (x *Xrpc) RepoChangeList(w http.ResponseWriter, r *http.Request) { 41 41 + repo := r.URL.Query().Get("repo") 42 42 + repoPath, err := x.parseRepoParam(repo) 43 43 + if err != nil { 44 44 + writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest) 45 45 + return 46 46 + } 47 47 + 48 48 + channel := r.URL.Query().Get("channel") 49 49 + cursor := r.URL.Query().Get("cursor") 50 50 + 51 51 + limit := 50 // default 52 52 + if limitStr := r.URL.Query().Get("limit"); limitStr != "" { 53 53 + if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 100 { 54 54 + limit = l 55 55 + } 56 56 + } 57 57 + 58 58 + rv, err := vcs.Open(repoPath, channel) 59 59 + if err != nil { 60 60 + writeError(w, xrpcerr.NewXrpcError( 61 61 + xrpcerr.WithTag("RepoNotFound"), 62 62 + xrpcerr.WithMessage("failed to open repository"), 63 63 + ), http.StatusNotFound) 64 64 + return 65 65 + } 66 66 + 67 67 + offset := 0 68 68 + if cursor != "" { 69 69 + if o, err := strconv.Atoi(cursor); err == nil && o >= 0 { 70 70 + offset = o 71 71 + } 72 72 + } 73 73 + 74 74 + entries, err := rv.History(offset, limit) 75 75 + if err != nil { 76 76 + x.Logger.Error("fetching changes", "error", err.Error()) 77 77 + writeError(w, xrpcerr.NewXrpcError( 78 78 + xrpcerr.WithTag("InternalServerError"), 79 79 + xrpcerr.WithMessage("failed to read change log"), 80 80 + ), http.StatusInternalServerError) 81 81 + return 82 82 + } 83 83 + 84 84 + total, err := rv.TotalHistoryEntries() 85 85 + if err != nil { 86 86 + x.Logger.Error("fetching total changes", "error", err.Error()) 87 87 + writeError(w, xrpcerr.NewXrpcError( 88 88 + xrpcerr.WithTag("InternalServerError"), 89 89 + xrpcerr.WithMessage("failed to fetch total changes"), 90 90 + ), http.StatusInternalServerError) 91 91 + return 92 92 + } 93 93 + 94 94 + // Collect all author keys to resolve to DIDs 95 95 + authorKeys := make([]string, 0, len(entries)) 96 96 + for _, e := range entries { 97 97 + if e.Author.Name != "" { 98 98 + authorKeys = append(authorKeys, e.Author.Name) 99 99 + } 100 100 + } 101 101 + keyToDid, err := x.Db.GetPijulKeyToDid(authorKeys) 102 102 + if err != nil { 103 103 + x.Logger.Warn("failed to resolve pijul keys to DIDs", "error", err) 104 104 + keyToDid = make(map[string]string) 105 105 + } 106 106 + 107 107 + // Convert to response format 108 108 + changeEntries := make([]PijulChangeEntry, len(entries)) 109 109 + for i, e := range entries { 110 110 + author := PijulAuthor{ 111 111 + Name: e.Author.Name, 112 112 + Email: e.Author.Email, 113 113 + } 114 114 + if did, ok := keyToDid[e.Author.Name]; ok { 115 115 + author.Did = did 116 116 + } 117 117 + 118 118 + changeEntries[i] = PijulChangeEntry{ 119 119 + Hash: e.Hash, 120 120 + Authors: []PijulAuthor{author}, 121 121 + Message: e.Message, 122 122 + Dependencies: e.Parents, 123 123 + } 124 124 + 125 125 + if !e.Timestamp.IsZero() { 126 126 + changeEntries[i].Timestamp = e.Timestamp.Format(time.RFC3339) 127 127 + } 128 128 + } 129 129 + 130 130 + response := PijulChangeListResponse{ 131 131 + Changes: changeEntries, 132 132 + Channel: channel, 133 133 + Page: (offset / limit) + 1, 134 134 + PerPage: limit, 135 135 + Total: total, 136 136 + } 137 137 + 138 138 + writeJson(w, response) 139 139 + } 140 140 + 141 141 + // PijulChangeGetResponse is the response for getting a single change 142 142 + type PijulChangeGetResponse struct { 143 143 + Hash string `json:"hash"` 144 144 + Authors []PijulAuthor `json:"authors"` 145 145 + Message string `json:"message"` 146 146 + Timestamp string `json:"timestamp,omitempty"` 147 147 + Dependencies []string `json:"dependencies,omitempty"` 148 148 + Diff string `json:"diff,omitempty"` 149 149 + } 150 150 + 151 151 + // RepoChangeGet handles the sh.tangled.repo.changeGet endpoint 152 152 + // Gets details for a specific change 153 153 + func (x *Xrpc) RepoChangeGet(w http.ResponseWriter, r *http.Request) { 154 154 + repo := r.URL.Query().Get("repo") 155 155 + repoPath, err := x.parseRepoParam(repo) 156 156 + if err != nil { 157 157 + writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest) 158 158 + return 159 159 + } 160 160 + 161 161 + hash := r.URL.Query().Get("hash") 162 162 + if hash == "" { 163 163 + writeError(w, xrpcerr.NewXrpcError( 164 164 + xrpcerr.WithTag("InvalidRequest"), 165 165 + xrpcerr.WithMessage("missing hash parameter"), 166 166 + ), http.StatusBadRequest) 167 167 + return 168 168 + } 169 169 + 170 170 + rv, err := vcs.Open(repoPath, "") 171 171 + if err != nil { 172 172 + writeError(w, xrpcerr.NewXrpcError( 173 173 + xrpcerr.WithTag("RepoNotFound"), 174 174 + xrpcerr.WithMessage("failed to open repository"), 175 175 + ), http.StatusNotFound) 176 176 + return 177 177 + } 178 178 + 179 179 + entry, err := rv.HistoryEntry(hash) 180 180 + if err != nil { 181 181 + x.Logger.Error("fetching change", "error", err.Error(), "hash", hash) 182 182 + writeError(w, xrpcerr.NewXrpcError( 183 183 + xrpcerr.WithTag("ChangeNotFound"), 184 184 + xrpcerr.WithMessage("change not found"), 185 185 + ), http.StatusNotFound) 186 186 + return 187 187 + } 188 188 + 189 189 + author := PijulAuthor{ 190 190 + Name: entry.Author.Name, 191 191 + Email: entry.Author.Email, 192 192 + } 193 193 + if did, err := x.Db.GetDidForPijulKey(entry.Author.Name); err == nil { 194 194 + author.Did = did 195 195 + } 196 196 + 197 197 + response := PijulChangeGetResponse{ 198 198 + Hash: entry.Hash, 199 199 + Authors: []PijulAuthor{author}, 200 200 + Message: entry.Message, 201 201 + Dependencies: entry.Parents, 202 202 + } 203 203 + 204 204 + if !entry.Timestamp.IsZero() { 205 205 + response.Timestamp = entry.Timestamp.Format(time.RFC3339) 206 206 + } 207 207 + 208 208 + // Get diff for pijul repos 209 209 + if pr := vcs.AsPijul(rv); pr != nil { 210 210 + diff, err := pr.DiffChange(hash) 211 211 + if err != nil { 212 212 + x.Logger.Warn("failed to get diff for change", "hash", hash, "error", err) 213 213 + } else if diff != nil { 214 214 + response.Diff = diff.Raw 215 215 + } 216 216 + } 217 217 + 218 218 + writeJson(w, response) 219 219 + }

+95

knotserver/xrpc/pijul_channels.go

reviewed

··· 1 1 + package xrpc 2 2 + 3 3 + import ( 4 4 + "net/http" 5 5 + 6 6 + "tangled.org/core/knotserver/vcs" 7 7 + xrpcerr "tangled.org/core/xrpc/errors" 8 8 + ) 9 9 + 10 10 + // PijulChannelListResponse is the response for listing Pijul channels 11 11 + type PijulChannelListResponse struct { 12 12 + Channels []PijulChannel `json:"channels"` 13 13 + } 14 14 + 15 15 + // PijulChannel represents a Pijul channel 16 16 + type PijulChannel struct { 17 17 + Name string `json:"name"` 18 18 + IsCurrent bool `json:"is_current,omitempty"` 19 19 + } 20 20 + 21 21 + // RepoChannelList handles the sh.tangled.repo.channelList endpoint 22 22 + // Kept for backwards compatibility - delegates to the unified Branches interface. 23 23 + func (x *Xrpc) RepoChannelList(w http.ResponseWriter, r *http.Request) { 24 24 + repo := r.URL.Query().Get("repo") 25 25 + repoPath, err := x.parseRepoParam(repo) 26 26 + if err != nil { 27 27 + writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest) 28 28 + return 29 29 + } 30 30 + 31 31 + rv, err := vcs.PlainOpen(repoPath) 32 32 + if err != nil { 33 33 + writeError(w, xrpcerr.NewXrpcError( 34 34 + xrpcerr.WithTag("RepoNotFound"), 35 35 + xrpcerr.WithMessage("failed to open repository"), 36 36 + ), http.StatusNotFound) 37 37 + return 38 38 + } 39 39 + 40 40 + branches, err := rv.Branches(nil) 41 41 + if err != nil { 42 42 + x.Logger.Error("fetching channels", "error", err.Error()) 43 43 + writeError(w, xrpcerr.NewXrpcError( 44 44 + xrpcerr.WithTag("InternalServerError"), 45 45 + xrpcerr.WithMessage("failed to list channels"), 46 46 + ), http.StatusInternalServerError) 47 47 + return 48 48 + } 49 49 + 50 50 + channelList := make([]PijulChannel, len(branches)) 51 51 + for i, b := range branches { 52 52 + channelList[i] = PijulChannel{ 53 53 + Name: b.Name, 54 54 + IsCurrent: b.IsDefault, 55 55 + } 56 56 + } 57 57 + 58 58 + writeJson(w, PijulChannelListResponse{Channels: channelList}) 59 59 + } 60 60 + 61 61 + // PijulGetDefaultChannelResponse is the response for getting the default channel 62 62 + type PijulGetDefaultChannelResponse struct { 63 63 + Channel string `json:"channel"` 64 64 + } 65 65 + 66 66 + // RepoGetDefaultChannel handles the sh.tangled.repo.getDefaultChannel endpoint 67 67 + func (x *Xrpc) RepoGetDefaultChannel(w http.ResponseWriter, r *http.Request) { 68 68 + repo := r.URL.Query().Get("repo") 69 69 + repoPath, err := x.parseRepoParam(repo) 70 70 + if err != nil { 71 71 + writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest) 72 72 + return 73 73 + } 74 74 + 75 75 + rv, err := vcs.PlainOpen(repoPath) 76 76 + if err != nil { 77 77 + writeError(w, xrpcerr.NewXrpcError( 78 78 + xrpcerr.WithTag("RepoNotFound"), 79 79 + xrpcerr.WithMessage("failed to open repository"), 80 80 + ), http.StatusNotFound) 81 81 + return 82 82 + } 83 83 + 84 84 + channel, err := rv.DefaultBranch() 85 85 + if err != nil { 86 86 + x.Logger.Error("finding default channel", "error", err.Error()) 87 87 + writeError(w, xrpcerr.NewXrpcError( 88 88 + xrpcerr.WithTag("InternalServerError"), 89 89 + xrpcerr.WithMessage("failed to find default channel"), 90 90 + ), http.StatusInternalServerError) 91 91 + return 92 92 + } 93 93 + 94 94 + writeJson(w, PijulGetDefaultChannelResponse{Channel: channel}) 95 95 + }

+85

knotserver/xrpc/pijul_tree.go

reviewed

··· 1 1 + package xrpc 2 2 + 3 3 + import ( 4 4 + "net/http" 5 5 + 6 6 + "tangled.org/core/knotserver/vcs" 7 7 + xrpcerr "tangled.org/core/xrpc/errors" 8 8 + 9 9 + "tangled.org/core/api/tangled" 10 10 + ) 11 11 + 12 12 + // RepoPijulTree is kept as an alias for backwards compatibility. 13 13 + // It delegates to the unified RepoTree handler. 14 14 + func (x *Xrpc) RepoPijulTree(w http.ResponseWriter, r *http.Request) { 15 15 + // Map channel param to ref if present, then delegate 16 16 + q := r.URL.Query() 17 17 + if channel := q.Get("channel"); channel != "" && q.Get("ref") == "" { 18 18 + q.Set("ref", channel) 19 19 + r.URL.RawQuery = q.Encode() 20 20 + } 21 21 + x.RepoTree(w, r) 22 22 + } 23 23 + 24 24 + // RepoPijulBlob handles the sh.tangled.repo.pijulBlob endpoint 25 25 + // Returns file content from a Pijul repository 26 26 + func (x *Xrpc) RepoPijulBlob(w http.ResponseWriter, r *http.Request) { 27 27 + repo := r.URL.Query().Get("repo") 28 28 + repoPath, err := x.parseRepoParam(repo) 29 29 + if err != nil { 30 30 + writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest) 31 31 + return 32 32 + } 33 33 + 34 34 + channel := r.URL.Query().Get("channel") 35 35 + path := r.URL.Query().Get("path") 36 36 + 37 37 + if path == "" { 38 38 + writeError(w, xrpcerr.NewXrpcError( 39 39 + xrpcerr.WithTag("InvalidRequest"), 40 40 + xrpcerr.WithMessage("missing path parameter"), 41 41 + ), http.StatusBadRequest) 42 42 + return 43 43 + } 44 44 + 45 45 + rv, err := vcs.Open(repoPath, channel) 46 46 + if err != nil { 47 47 + writeError(w, xrpcerr.NewXrpcError( 48 48 + xrpcerr.WithTag("RepoNotFound"), 49 49 + xrpcerr.WithMessage("failed to open pijul repository"), 50 50 + ), http.StatusNotFound) 51 51 + return 52 52 + } 53 53 + 54 54 + // Try to read as text first 55 55 + const maxSize = 1024 * 1024 // 1MB 56 56 + content, err := rv.FileContentN(path, maxSize) 57 57 + if err != nil { 58 58 + if vcs.IsBinaryFileError(err) { 59 59 + // Return binary indicator 60 60 + response := tangled.RepoPijulBlob_Output{ 61 61 + Is_binary: true, 62 62 + Path: path, 63 63 + Ref: &channel, 64 64 + } 65 65 + writeJson(w, response) 66 66 + return 67 67 + } 68 68 + 69 69 + x.Logger.Error("failed to read file", "error", err, "path", path) 70 70 + writeError(w, xrpcerr.NewXrpcError( 71 71 + xrpcerr.WithTag("PathNotFound"), 72 72 + xrpcerr.WithMessage("failed to read file"), 73 73 + ), http.StatusNotFound) 74 74 + return 75 75 + } 76 76 + 77 77 + contentStr := string(content) 78 78 + response := tangled.RepoPijulBlob_Output{ 79 79 + Contents: &contentStr, 80 80 + Path: path, 81 81 + Ref: &channel, 82 82 + } 83 83 + 84 84 + writeJson(w, response) 85 85 + }

+127

knotserver/xrpc/pijul_unrecord.go

reviewed

··· 1 1 + package xrpc 2 2 + 3 3 + import ( 4 4 + "encoding/json" 5 5 + "net/http" 6 6 + "strings" 7 7 + 8 8 + "github.com/bluesky-social/indigo/atproto/syntax" 9 9 + "tangled.org/core/knotserver/pijul" 10 10 + "tangled.org/core/rbac" 11 11 + xrpcerr "tangled.org/core/xrpc/errors" 12 12 + ) 13 13 + 14 14 + // UnrecordChangesRequest is the request body for unrecording changes 15 15 + type UnrecordChangesRequest struct { 16 16 + Repo string `json:"repo"` 17 17 + Channel string `json:"channel,omitempty"` 18 18 + Changes []string `json:"changes"` 19 19 + } 20 20 + 21 21 + // UnrecordChangesResponse is the response for unrecording changes 22 22 + type UnrecordChangesResponse struct { 23 23 + Unrecorded []string `json:"unrecorded"` 24 24 + Failed []ApplyChangeFailure `json:"failed,omitempty"` 25 25 + } 26 26 + 27 27 + // RepoUnrecordChanges handles the sh.tangled.repo.unrecordChanges endpoint 28 28 + // Unrecords (reverts) Pijul changes from a repository channel 29 29 + func (x *Xrpc) RepoUnrecordChanges(w http.ResponseWriter, r *http.Request) { 30 30 + if r.Method != http.MethodPost { 31 31 + writeError(w, xrpcerr.NewXrpcError( 32 32 + xrpcerr.WithTag("InvalidRequest"), 33 33 + xrpcerr.WithMessage("method not allowed"), 34 34 + ), http.StatusMethodNotAllowed) 35 35 + return 36 36 + } 37 37 + 38 38 + var req UnrecordChangesRequest 39 39 + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { 40 40 + writeError(w, xrpcerr.NewXrpcError( 41 41 + xrpcerr.WithTag("InvalidRequest"), 42 42 + xrpcerr.WithMessage("invalid request body"), 43 43 + ), http.StatusBadRequest) 44 44 + return 45 45 + } 46 46 + 47 47 + if req.Repo == "" || len(req.Changes) == 0 { 48 48 + writeError(w, xrpcerr.NewXrpcError( 49 49 + xrpcerr.WithTag("InvalidRequest"), 50 50 + xrpcerr.WithMessage("repo and changes are required"), 51 51 + ), http.StatusBadRequest) 52 52 + return 53 53 + } 54 54 + 55 55 + // Authorization: verify the caller has push permission 56 56 + actorDid, ok := r.Context().Value(ActorDid).(syntax.DID) 57 57 + if !ok { 58 58 + writeError(w, xrpcerr.MissingActorDidError, http.StatusBadRequest) 59 59 + return 60 60 + } 61 61 + 62 62 + repoPath, err := x.parseRepoParam(req.Repo) 63 63 + if err != nil { 64 64 + writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest) 65 65 + return 66 66 + } 67 67 + 68 68 + repoParts := strings.SplitN(req.Repo, "/", 2) 69 69 + if len(repoParts) != 2 { 70 70 + writeError(w, xrpcerr.NewXrpcError( 71 71 + xrpcerr.WithTag("InvalidRequest"), 72 72 + xrpcerr.WithMessage("invalid repo format"), 73 73 + ), http.StatusBadRequest) 74 74 + return 75 75 + } 76 76 + repoDid, dbErr := x.Db.GetRepoDid(repoParts[0], repoParts[1]) 77 77 + if dbErr != nil { 78 78 + repoDid = repoParts[0] + "/" + repoParts[1] 79 79 + } 80 80 + pushOk, err := x.Enforcer.IsPushAllowed(actorDid.String(), rbac.ThisServer, repoDid) 81 81 + if err != nil || !pushOk { 82 82 + writeError(w, xrpcerr.NewXrpcError( 83 83 + xrpcerr.WithTag("Forbidden"), 84 84 + xrpcerr.WithMessage("push permission required to unrecord changes"), 85 85 + ), http.StatusForbidden) 86 86 + return 87 87 + } 88 88 + 89 89 + // Open the repository with the target channel 90 90 + pr, err := pijul.Open(repoPath, req.Channel) 91 91 + if err != nil { 92 92 + writeError(w, xrpcerr.NewXrpcError( 93 93 + xrpcerr.WithTag("RepoNotFound"), 94 94 + xrpcerr.WithMessage("failed to open pijul repository"), 95 95 + ), http.StatusNotFound) 96 96 + return 97 97 + } 98 98 + 99 99 + // Unrecord each change 100 100 + response := UnrecordChangesResponse{ 101 101 + Unrecorded: make([]string, 0), 102 102 + Failed: make([]ApplyChangeFailure, 0), 103 103 + } 104 104 + 105 105 + for _, changeHash := range req.Changes { 106 106 + if err := pr.Unrecord(changeHash); err != nil { 107 107 + x.Logger.Error("failed to unrecord change", "hash", changeHash, "error", err.Error()) 108 108 + response.Failed = append(response.Failed, ApplyChangeFailure{ 109 109 + Hash: changeHash, 110 110 + Error: err.Error(), 111 111 + }) 112 112 + } else { 113 113 + response.Unrecorded = append(response.Unrecorded, changeHash) 114 114 + x.Logger.Info("unrecorded change", "hash", changeHash, "channel", req.Channel) 115 115 + } 116 116 + } 117 117 + 118 118 + if len(response.Failed) > 0 && len(response.Unrecorded) == 0 { 119 119 + writeError(w, xrpcerr.NewXrpcError( 120 120 + xrpcerr.WithTag("UnrecordFailed"), 121 121 + xrpcerr.WithMessage("all changes failed to unrecord"), 122 122 + ), http.StatusInternalServerError) 123 123 + return 124 124 + } 125 125 + 126 126 + writeJson(w, response) 127 127 + }

+36 -7

knotserver/xrpc/repo_branches.go

reviewed

··· 4 4 "net/http" 5 5 "strconv" 6 6 7 7 - "tangled.org/core/knotserver/git" 7 7 + "github.com/go-git/go-git/v5/plumbing" 8 8 + "github.com/go-git/go-git/v5/plumbing/object" 9 9 + "tangled.org/core/knotserver/vcs" 8 10 "tangled.org/core/types" 9 11 xrpcerr "tangled.org/core/xrpc/errors" 10 12 ) ··· 29 31 offset = o 30 32 } 31 33 32 32 - gr, err := git.PlainOpen(repoPath) 34 34 + rv, err := vcs.PlainOpen(repoPath) 33 35 if err != nil { 34 36 writeError(w, xrpcerr.RepoNotFoundError, http.StatusNoContent) 35 37 return 36 38 } 37 39 38 38 - branches, _ := gr.Branches(&git.BranchesOptions{ 40 40 + branchInfos, err := rv.Branches(&vcs.PaginationOpts{ 39 41 Limit: limit, 40 42 Offset: offset, 41 43 }) 44 44 + if err != nil { 45 45 + writeError(w, xrpcerr.GenericError(err), http.StatusInternalServerError) 46 46 + return 47 47 + } 42 48 43 43 - // Create response using existing types.RepoBranchesResponse 44 44 - response := types.RepoBranchesResponse{ 45 45 - Branches: branches, 49 49 + branches := make([]types.Branch, 0, len(branchInfos)) 50 50 + for _, bi := range branchInfos { 51 51 + b := types.Branch{ 52 52 + Reference: types.Reference{ 53 53 + Name: bi.Name, 54 54 + Hash: bi.Hash, 55 55 + }, 56 56 + IsDefault: bi.IsDefault, 57 57 + } 58 58 + if bi.LatestEntry != nil { 59 59 + b.Commit = &object.Commit{ 60 60 + Hash: plumbing.NewHash(bi.LatestEntry.Hash), 61 61 + Author: object.Signature{ 62 62 + Name: bi.LatestEntry.Author.Name, 63 63 + Email: bi.LatestEntry.Author.Email, 64 64 + When: bi.LatestEntry.Author.When, 65 65 + }, 66 66 + Committer: object.Signature{ 67 67 + Name: bi.LatestEntry.Committer.Name, 68 68 + Email: bi.LatestEntry.Committer.Email, 69 69 + When: bi.LatestEntry.Committer.When, 70 70 + }, 71 71 + Message: bi.LatestEntry.Message, 72 72 + } 73 73 + } 74 74 + branches = append(branches, b) 46 75 } 47 76 48 48 - writeJson(w, response) 77 77 + writeJson(w, types.RepoBranchesResponse{Branches: branches}) 49 78 }

+8 -3

knotserver/xrpc/repo_get_default_branch.go

reviewed

··· 5 5 "time" 6 6 7 7 "tangled.org/core/api/tangled" 8 8 - "tangled.org/core/knotserver/git" 8 8 + "tangled.org/core/knotserver/vcs" 9 9 xrpcerr "tangled.org/core/xrpc/errors" 10 10 ) 11 11 ··· 17 17 return 18 18 } 19 19 20 20 - gr, err := git.PlainOpen(repoPath) 20 20 + rv, err := vcs.PlainOpen(repoPath) 21 21 + if err != nil { 22 22 + x.Logger.Error("failed to open repository", "error", err) 23 23 + writeError(w, xrpcerr.RepoNotFoundError, http.StatusNoContent) 24 24 + return 25 25 + } 21 26 22 22 - branch, err := gr.FindMainBranch() 27 27 + branch, err := rv.DefaultBranch() 23 28 if err != nil { 24 29 x.Logger.Error("getting default branch", "error", err.Error()) 25 30 writeError(w, xrpcerr.NewXrpcError(

+37 -11

knotserver/xrpc/repo_log.go

reviewed

··· 4 4 "net/http" 5 5 "strconv" 6 6 7 7 - "tangled.org/core/knotserver/git" 7 7 + "github.com/go-git/go-git/v5/plumbing" 8 8 + "github.com/go-git/go-git/v5/plumbing/object" 9 9 + "tangled.org/core/knotserver/vcs" 8 10 "tangled.org/core/types" 9 11 xrpcerr "tangled.org/core/xrpc/errors" 10 12 ) ··· 29 31 } 30 32 } 31 33 32 32 - gr, err := git.Open(repoPath, ref) 34 34 + rv, err := vcs.Open(repoPath, ref) 33 35 if err != nil { 34 36 writeError(w, xrpcerr.RefNotFoundError, http.StatusNotFound) 35 37 return 36 38 } 37 39 40 40 + // If ref was empty, resolve the actual default branch name 41 41 + if ref == "" { 42 42 + if defaultBranch, err := rv.DefaultBranch(); err == nil { 43 43 + ref = defaultBranch 44 44 + } 45 45 + } 46 46 + 38 47 offset := 0 39 48 if cursor != "" { 40 49 if o, err := strconv.Atoi(cursor); err == nil && o >= 0 { ··· 42 51 } 43 52 } 44 53 45 45 - commits, err := gr.Commits(offset, limit) 54 54 + entries, err := rv.History(offset, limit) 46 55 if err != nil { 47 47 - x.Logger.Error("fetching commits", "error", err.Error()) 56 56 + x.Logger.Error("fetching history", "error", err.Error()) 48 57 writeError(w, xrpcerr.NewXrpcError( 49 58 xrpcerr.WithTag("PathNotFound"), 50 59 xrpcerr.WithMessage("failed to read commit log"), ··· 52 61 return 53 62 } 54 63 55 55 - total, err := gr.TotalCommits() 64 64 + total, err := rv.TotalHistoryEntries() 56 65 if err != nil { 57 57 - x.Logger.Error("fetching total commits", "error", err.Error()) 66 66 + x.Logger.Error("fetching total history entries", "error", err.Error()) 58 67 writeError(w, xrpcerr.NewXrpcError( 59 68 xrpcerr.WithTag("InternalServerError"), 60 69 xrpcerr.WithMessage("failed to fetch total commits"), 61 61 - ), http.StatusNotFound) 70 70 + ), http.StatusInternalServerError) 62 71 return 63 72 } 64 73 65 65 - tcommits := make([]types.Commit, len(commits)) 66 66 - for i, c := range commits { 67 67 - tcommits[i].FromGoGitCommit(c) 74 74 + tcommits := make([]types.Commit, len(entries)) 75 75 + for i, e := range entries { 76 76 + parents := make([]plumbing.Hash, 0, len(e.Parents)) 77 77 + for _, p := range e.Parents { 78 78 + parents = append(parents, plumbing.NewHash(p)) 79 79 + } 80 80 + tcommits[i] = types.Commit{ 81 81 + Hash: plumbing.NewHash(e.Hash), 82 82 + Author: object.Signature{ 83 83 + Name: e.Author.Name, 84 84 + Email: e.Author.Email, 85 85 + When: e.Author.When, 86 86 + }, 87 87 + Committer: object.Signature{ 88 88 + Name: e.Committer.Name, 89 89 + Email: e.Committer.Email, 90 90 + When: e.Committer.When, 91 91 + }, 92 92 + Message: e.Message, 93 93 + ParentHashes: parents, 94 94 + } 68 95 } 69 96 70 70 - // Create response using existing types.RepoLogResponse 71 97 response := types.RepoLogResponse{ 72 98 Commits: tcommits, 73 99 Ref: ref,

+110

knotserver/xrpc/repo_permissions.go

reviewed

··· 1 1 + package xrpc 2 2 + 3 3 + import ( 4 4 + "net/http" 5 5 + "os" 6 6 + "slices" 7 7 + "strings" 8 8 + 9 9 + "github.com/bluesky-social/indigo/atproto/syntax" 10 10 + securejoin "github.com/cyphar/filepath-securejoin" 11 11 + "tangled.org/core/api/tangled" 12 12 + "tangled.org/core/rbac" 13 13 + xrpcerr "tangled.org/core/xrpc/errors" 14 14 + ) 15 15 + 16 16 + const ( 17 17 + permPush int64 = 1 << iota 18 18 + permSettings 19 19 + permCreateDiscussion 20 20 + permEditDiscussion 21 21 + permTagDiscussion 22 22 + permOwner 23 23 + permInvite 24 24 + permDelete 25 25 + ) 26 26 + 27 27 + // RepoPermissions returns the permissions the authenticated user has on a repository. 28 28 + // This endpoint is VCS-agnostic — it works for both git and pijul repos. 29 29 + func (x *Xrpc) RepoPermissions(w http.ResponseWriter, r *http.Request) { 30 30 + l := x.Logger.With("handler", "RepoPermissions") 31 31 + fail := func(e xrpcerr.XrpcError, status int) { 32 32 + l.Error("failed", "kind", e.Tag, "error", e.Message) 33 33 + writeError(w, e, status) 34 34 + } 35 35 + 36 36 + actorDid, ok := r.Context().Value(ActorDid).(syntax.DID) 37 37 + if !ok { 38 38 + fail(xrpcerr.MissingActorDidError, http.StatusBadRequest) 39 39 + return 40 40 + } 41 41 + 42 42 + repo := r.URL.Query().Get("repo") 43 43 + if repo == "" { 44 44 + fail(xrpcerr.NewXrpcError( 45 45 + xrpcerr.WithTag("InvalidRequest"), 46 46 + xrpcerr.WithMessage("missing repo parameter"), 47 47 + ), http.StatusBadRequest) 48 48 + return 49 49 + } 50 50 + 51 51 + repoPath, err := x.parseRepoParam(repo) 52 52 + if err != nil { 53 53 + fail(err.(xrpcerr.XrpcError), http.StatusBadRequest) 54 54 + return 55 55 + } 56 56 + 57 57 + if _, err := os.Stat(repoPath); err != nil { 58 58 + if os.IsNotExist(err) { 59 59 + writeError(w, xrpcerr.RepoNotFoundError, http.StatusNoContent) 60 60 + return 61 61 + } 62 62 + fail(xrpcerr.GenericError(err), http.StatusInternalServerError) 63 63 + return 64 64 + } 65 65 + 66 66 + repoParts := strings.SplitN(repo, "/", 2) 67 67 + if len(repoParts) != 2 { 68 68 + fail(xrpcerr.NewXrpcError( 69 69 + xrpcerr.WithTag("InvalidRequest"), 70 70 + xrpcerr.WithMessage("invalid repo format, expected 'did/repoName'"), 71 71 + ), http.StatusBadRequest) 72 72 + return 73 73 + } 74 74 + 75 75 + didSlashRepo, err := securejoin.SecureJoin(repoParts[0], repoParts[1]) 76 76 + if err != nil { 77 77 + fail(xrpcerr.InvalidRepoError(repo), http.StatusBadRequest) 78 78 + return 79 79 + } 80 80 + 81 81 + roles := x.Enforcer.GetPermissionsInRepo(actorDid.String(), rbac.ThisServer, didSlashRepo) 82 82 + 83 83 + var mask int64 84 84 + var permissions []string 85 85 + add := func(name string, bit int64, ok bool) { 86 86 + if !ok { 87 87 + return 88 88 + } 89 89 + mask |= bit 90 90 + permissions = append(permissions, name) 91 91 + } 92 92 + 93 93 + has := func(perm string) bool { 94 94 + return slices.Contains(roles, perm) 95 95 + } 96 96 + 97 97 + add("push", permPush, has("repo:push")) 98 98 + add("settings", permSettings, has("repo:settings")) 99 99 + add("create_discussion", permCreateDiscussion, has("repo:create_discussion")) 100 100 + add("edit_discussion", permEditDiscussion, has("repo:edit_discussion")) 101 101 + add("tag_discussion", permTagDiscussion, has("repo:tag_discussion")) 102 102 + add("owner", permOwner, has("repo:owner")) 103 103 + add("invite", permInvite, has("repo:invite")) 104 104 + add("delete", permDelete, has("repo:delete")) 105 105 + 106 106 + writeJson(w, tangled.RepoPermissions_Output{ 107 107 + Mask: mask, 108 108 + Permissions: permissions, 109 109 + }) 110 110 + }

+12 -1

knotserver/xrpc/repo_tag.go

reviewed

··· 8 8 "github.com/go-git/go-git/v5/plumbing/object" 9 9 10 10 "tangled.org/core/knotserver/git" 11 11 + "tangled.org/core/knotserver/vcs" 11 12 "tangled.org/core/types" 12 13 xrpcerr "tangled.org/core/xrpc/errors" 13 14 ) ··· 29 30 return 30 31 } 31 32 32 32 - gr, err := git.PlainOpen(repoPath) 33 33 + rv, err := vcs.PlainOpen(repoPath) 33 34 if err != nil { 34 35 x.Logger.Error("failed to open", "error", err) 35 36 writeError(w, xrpcerr.RepoNotFoundError, http.StatusNoContent) 37 37 + return 38 38 + } 39 39 + 40 40 + // pijul has no tags 41 41 + gr := vcs.AsGit(rv) 42 42 + if gr == nil { 43 43 + writeError(w, xrpcerr.NewXrpcError( 44 44 + xrpcerr.WithTag("TagNotFound"), 45 45 + xrpcerr.WithMessage("tags are not supported for pijul repositories"), 46 46 + ), http.StatusNotFound) 36 47 return 37 48 } 38 49

+15 -7

knotserver/xrpc/repo_tags.go

reviewed

··· 8 8 "github.com/go-git/go-git/v5/plumbing/object" 9 9 10 10 "tangled.org/core/knotserver/git" 11 11 + "tangled.org/core/knotserver/vcs" 11 12 "tangled.org/core/types" 12 13 xrpcerr "tangled.org/core/xrpc/errors" 13 14 ) ··· 20 21 return 21 22 } 22 23 24 24 + rv, err := vcs.PlainOpen(repoPath) 25 25 + if err != nil { 26 26 + x.Logger.Error("failed to open", "error", err) 27 27 + writeError(w, xrpcerr.RepoNotFoundError, http.StatusNoContent) 28 28 + return 29 29 + } 30 30 + 31 31 + // pijul has no tags, return empty list 32 32 + gr := vcs.AsGit(rv) 33 33 + if gr == nil { 34 34 + writeJson(w, types.RepoTagsResponse{Tags: []*types.TagReference{}}) 35 35 + return 36 36 + } 37 37 + 23 38 // default 24 39 limit := 50 25 40 offset := 0 ··· 30 45 31 46 if o, err := strconv.Atoi(r.URL.Query().Get("cursor")); err == nil && o > 0 { 32 47 offset = o 33 33 - } 34 34 - 35 35 - gr, err := git.PlainOpen(repoPath) 36 36 - if err != nil { 37 37 - x.Logger.Error("failed to open", "error", err) 38 38 - writeError(w, xrpcerr.RepoNotFoundError, http.StatusNoContent) 39 39 - return 40 48 } 41 49 42 50 tags, err := gr.Tags(&git.TagsOptions{

+30 -19

knotserver/xrpc/repo_tree.go

reviewed

··· 6 6 "time" 7 7 "unicode/utf8" 8 8 9 9 + "github.com/go-git/go-git/v5/plumbing" 9 10 "tangled.org/core/api/tangled" 10 11 "tangled.org/core/appview/pages/markup" 11 11 - "tangled.org/core/knotserver/git" 12 12 - "tangled.org/core/types" 12 12 + "tangled.org/core/knotserver/vcs" 13 13 xrpcerr "tangled.org/core/xrpc/errors" 14 14 ) 15 15 ··· 24 24 } 25 25 26 26 ref := r.URL.Query().Get("ref") 27 27 - // ref can be empty (git.Open handles this) 27 27 + // For pijul, also accept "channel" param and fall back to default 28 28 + if channel := r.URL.Query().Get("channel"); channel != "" { 29 29 + ref = channel 30 30 + } 28 31 29 32 path := r.URL.Query().Get("path") 30 30 - // path can be empty (defaults to root) 31 33 32 32 - gr, err := git.Open(repoPath, ref) 34 34 + rv, err := vcs.Open(repoPath, ref) 33 35 if err != nil { 34 34 - x.Logger.Error("failed to open git repository", "error", err, "path", repoPath, "ref", ref) 36 36 + x.Logger.Error("failed to open repository", "error", err, "path", repoPath, "ref", ref) 35 37 writeError(w, xrpcerr.RefNotFoundError, http.StatusNotFound) 36 38 return 37 39 } 38 40 39 39 - files, err := gr.FileTree(ctx, path) 41 41 + files, err := rv.FileTree(ctx, path) 40 42 if err != nil { 41 43 x.Logger.Error("failed to get file tree", "error", err, "path", path) 42 44 writeError(w, xrpcerr.NewXrpcError( ··· 51 53 var readmeContents string 52 54 for _, file := range files { 53 55 if markup.IsReadmeFile(file.Name) { 54 54 - contents, err := gr.RawContent(filepath.Join(path, file.Name)) 56 56 + contents, err := rv.RawContent(filepath.Join(path, file.Name)) 55 57 if err != nil { 56 58 x.Logger.Error("failed to read contents of file", "path", path, "file", file.Name) 59 59 + continue 57 60 } 58 61 59 62 if utf8.Valid(contents) { ··· 64 67 } 65 68 } 66 69 67 67 - // convert NiceTree -> tangled.RepoTree_TreeEntry 70 70 + // convert vcs.TreeEntry -> tangled.RepoTree_TreeEntry 68 71 treeEntries := make([]*tangled.RepoTree_TreeEntry, len(files)) 69 72 for i, file := range files { 70 73 entry := &tangled.RepoTree_TreeEntry{ ··· 75 78 76 79 if file.LastCommit != nil { 77 80 entry.Last_commit = &tangled.RepoTree_LastCommit{ 78 78 - Hash: file.LastCommit.Hash.String(), 81 81 + Hash: file.LastCommit.Hash, 79 82 Message: file.LastCommit.Message, 80 83 When: file.LastCommit.When.Format(time.RFC3339), 81 84 } ··· 109 112 } 110 113 111 114 // calculate lastCommit for the directory as a whole 112 112 - var lastCommitTree *types.LastCommitInfo 113 113 - for _, e := range files { 115 115 + var lastCommitTree *vcs.LastCommitInfo 116 116 + for i := range files { 117 117 + e := &files[i] 114 118 if e.LastCommit == nil { 115 119 continue 116 120 } ··· 120 124 continue 121 125 } 122 126 123 123 - if lastCommitTree.When.After(e.LastCommit.When) { 127 127 + if lastCommitTree.When.Before(e.LastCommit.When) { 124 128 lastCommitTree = e.LastCommit 125 129 } 126 130 } 127 131 128 132 if lastCommitTree != nil { 129 133 response.LastCommit = &tangled.RepoTree_LastCommit{ 130 130 - Hash: lastCommitTree.Hash.String(), 134 134 + Hash: lastCommitTree.Hash, 131 135 Message: lastCommitTree.Message, 132 136 When: lastCommitTree.When.Format(time.RFC3339), 133 137 } 134 138 135 135 - // try to get author information 136 136 - commit, err := gr.Commit(lastCommitTree.Hash) 137 137 - if err == nil { 139 139 + if lastCommitTree.Author != nil { 138 140 response.LastCommit.Author = &tangled.RepoTree_Signature{ 139 139 - Name: commit.Author.Name, 140 140 - Email: commit.Author.Email, 141 141 + Name: lastCommitTree.Author.Name, 142 142 + Email: lastCommitTree.Author.Email, 143 143 + } 144 144 + } else if gr := vcs.AsGit(rv); gr != nil { 145 145 + // try to get author information from the git commit 146 146 + commit, err := gr.Commit(plumbing.NewHash(lastCommitTree.Hash)) 147 147 + if err == nil { 148 148 + response.LastCommit.Author = &tangled.RepoTree_Signature{ 149 149 + Name: commit.Author.Name, 150 150 + Email: commit.Author.Email, 151 151 + } 141 152 } 142 153 } 143 154 }

+9

knotserver/xrpc/xrpc.go

reviewed

··· 46 46 r.Post("/"+tangled.RepoForkSyncNSID, x.ForkSync) 47 47 r.Post("/"+tangled.RepoHiddenRefNSID, x.HiddenRef) 48 48 r.Post("/"+tangled.RepoMergeNSID, x.Merge) 49 49 + r.Post("/"+tangled.RepoApplyChangesNSID, x.RepoApplyChanges) 50 50 + r.Post("/"+tangled.RepoUnrecordChangesNSID, x.RepoUnrecordChanges) 51 51 + r.Get("/"+tangled.RepoPermissionsNSID, x.RepoPermissions) 49 52 }) 50 53 51 54 // merge check is an open endpoint ··· 62 65 r.Get("/"+tangled.RepoTagsNSID, x.RepoTags) 63 66 r.Get("/"+tangled.RepoTagNSID, x.RepoTag) 64 67 r.Get("/"+tangled.RepoBlobNSID, x.RepoBlob) 68 68 + r.Get("/"+tangled.RepoPijulBlobNSID, x.RepoPijulBlob) 65 69 r.Get("/"+tangled.RepoDiffNSID, x.RepoDiff) 66 70 r.Get("/"+tangled.RepoCompareNSID, x.RepoCompare) 67 71 r.Get("/"+tangled.RepoGetDefaultBranchNSID, x.RepoGetDefaultBranch) 72 72 + r.Get("/"+tangled.RepoGetDefaultChannelNSID, x.RepoGetDefaultChannel) 68 73 r.Get("/"+tangled.RepoBranchNSID, x.RepoBranch) 69 74 r.Get("/"+tangled.RepoArchiveNSID, x.RepoArchive) 70 75 r.Get("/"+tangled.RepoLanguagesNSID, x.RepoLanguages) 76 76 + r.Get("/"+tangled.RepoChannelListNSID, x.RepoChannelList) 77 77 + r.Get("/"+tangled.RepoChangeListNSID, x.RepoChangeList) 78 78 + r.Get("/"+tangled.RepoChangeGetNSID, x.RepoChangeGet) 79 79 + r.Get("/"+tangled.RepoPijulTreeNSID, x.RepoPijulTree) 71 80 72 81 // knot query endpoints (no auth required) 73 82 r.Get("/"+tangled.KnotListKeysNSID, x.ListKeys)

+51

lexicons/discussion/comment.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo.discussion.comment", 4 4 + "needsCbor": true, 5 5 + "needsType": true, 6 6 + "defs": { 7 7 + "main": { 8 8 + "type": "record", 9 9 + "key": "tid", 10 10 + "description": "A comment on a discussion", 11 11 + "record": { 12 12 + "type": "object", 13 13 + "required": ["discussion", "body", "createdAt"], 14 14 + "properties": { 15 15 + "discussion": { 16 16 + "type": "string", 17 17 + "format": "at-uri", 18 18 + "description": "The discussion this comment belongs to" 19 19 + }, 20 20 + "body": { 21 21 + "type": "string", 22 22 + "description": "Comment text" 23 23 + }, 24 24 + "replyTo": { 25 25 + "type": "string", 26 26 + "format": "at-uri", 27 27 + "description": "If this is a reply, the parent comment's at-uri" 28 28 + }, 29 29 + "createdAt": { 30 30 + "type": "string", 31 31 + "format": "datetime" 32 32 + }, 33 33 + "mentions": { 34 34 + "type": "array", 35 35 + "items": { 36 36 + "type": "string", 37 37 + "format": "did" 38 38 + } 39 39 + }, 40 40 + "references": { 41 41 + "type": "array", 42 42 + "items": { 43 43 + "type": "string", 44 44 + "format": "at-uri" 45 45 + } 46 46 + } 47 47 + } 48 48 + } 49 49 + } 50 50 + } 51 51 + }

+55

lexicons/discussion/discussion.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo.discussion", 4 4 + "needsCbor": true, 5 5 + "needsType": true, 6 6 + "defs": { 7 7 + "main": { 8 8 + "type": "record", 9 9 + "key": "tid", 10 10 + "description": "A discussion in a Pijul repository. Anyone can add patches to discussions.", 11 11 + "record": { 12 12 + "type": "object", 13 13 + "required": ["repo", "title", "createdAt"], 14 14 + "properties": { 15 15 + "repo": { 16 16 + "type": "string", 17 17 + "format": "at-uri", 18 18 + "description": "The repository this discussion belongs to" 19 19 + }, 20 20 + "title": { 21 21 + "type": "string", 22 22 + "description": "Discussion title" 23 23 + }, 24 24 + "body": { 25 25 + "type": "string", 26 26 + "description": "Discussion body/description" 27 27 + }, 28 28 + "targetChannel": { 29 29 + "type": "string", 30 30 + "description": "Target Pijul channel for merging patches", 31 31 + "default": "main" 32 32 + }, 33 33 + "createdAt": { 34 34 + "type": "string", 35 35 + "format": "datetime" 36 36 + }, 37 37 + "mentions": { 38 38 + "type": "array", 39 39 + "items": { 40 40 + "type": "string", 41 41 + "format": "did" 42 42 + } 43 43 + }, 44 44 + "references": { 45 45 + "type": "array", 46 46 + "items": { 47 47 + "type": "string", 48 48 + "format": "at-uri" 49 49 + } 50 50 + } 51 51 + } 52 52 + } 53 53 + } 54 54 + } 55 55 + }

+33

lexicons/discussion/state.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo.discussion.state", 4 4 + "needsCbor": true, 5 5 + "needsType": true, 6 6 + "defs": { 7 7 + "main": { 8 8 + "type": "record", 9 9 + "key": "tid", 10 10 + "description": "A state change event for a discussion (close, reopen, merge)", 11 11 + "record": { 12 12 + "type": "object", 13 13 + "required": ["discussion", "state", "createdAt"], 14 14 + "properties": { 15 15 + "discussion": { 16 16 + "type": "string", 17 17 + "format": "at-uri", 18 18 + "description": "The discussion this state change applies to" 19 19 + }, 20 20 + "state": { 21 21 + "type": "string", 22 22 + "knownValues": ["open", "closed", "merged"], 23 23 + "description": "The new state of the discussion" 24 24 + }, 25 25 + "createdAt": { 26 26 + "type": "string", 27 27 + "format": "datetime" 28 28 + } 29 29 + } 30 30 + } 31 31 + } 32 32 + } 33 33 + }

+50

lexicons/pijul/refUpdate.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.pijul.refUpdate", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "record", 7 7 + "description": "Published to the committer's PDS when pijul changes are pushed to a channel. The PDS MST signature over this record is the verifiable proof of authorship.", 8 8 + "key": "tid", 9 9 + "record": { 10 10 + "type": "object", 11 11 + "required": ["repo", "channel", "newState", "changes", "committerDid"], 12 12 + "properties": { 13 13 + "repo": { 14 14 + "type": "string", 15 15 + "format": "at-uri", 16 16 + "description": "AT URI of the repository (at://did/sh.tangled.repo/name)" 17 17 + }, 18 18 + "channel": { 19 19 + "type": "string", 20 20 + "description": "Channel that was updated" 21 21 + }, 22 22 + "oldState": { 23 23 + "type": "string", 24 24 + "description": "Pijul Merkle state hash before push (empty for new channels)" 25 25 + }, 26 26 + "newState": { 27 27 + "type": "string", 28 28 + "description": "Pijul Merkle state hash after push" 29 29 + }, 30 30 + "changes": { 31 31 + "type": "array", 32 32 + "items": { 33 33 + "type": "string" 34 34 + }, 35 35 + "description": "Base32 change hashes pushed in this operation, in application order" 36 36 + }, 37 37 + "committerDid": { 38 38 + "type": "string", 39 39 + "format": "did", 40 40 + "description": "DID of the pusher. Redundant when this record lives in the committer's own PDS, but preserved for replication." 41 41 + }, 42 42 + "languages": { 43 43 + "type": "object", 44 44 + "description": "Optional map of language name to line count, computed by knot server" 45 45 + } 46 46 + } 47 47 + } 48 48 + } 49 49 + } 50 50 + }

+84

lexicons/repo/applyChanges.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo.applyChanges", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Apply Pijul changes to a repository channel. Used for merging discussions.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["repo", "channel", "changes"], 13 13 + "properties": { 14 14 + "repo": { 15 15 + "type": "string", 16 16 + "description": "Repository identifier in format 'did:plc:.../repoName'" 17 17 + }, 18 18 + "channel": { 19 19 + "type": "string", 20 20 + "description": "Target channel to apply changes to" 21 21 + }, 22 22 + "changes": { 23 23 + "type": "array", 24 24 + "items": { 25 25 + "type": "string" 26 26 + }, 27 27 + "description": "List of change hashes to apply (in order)" 28 28 + } 29 29 + } 30 30 + } 31 31 + }, 32 32 + "output": { 33 33 + "encoding": "application/json", 34 34 + "schema": { 35 35 + "type": "object", 36 36 + "required": ["applied"], 37 37 + "properties": { 38 38 + "applied": { 39 39 + "type": "array", 40 40 + "items": { 41 41 + "type": "string" 42 42 + }, 43 43 + "description": "List of successfully applied change hashes" 44 44 + }, 45 45 + "failed": { 46 46 + "type": "array", 47 47 + "items": { 48 48 + "type": "object", 49 49 + "required": ["hash", "error"], 50 50 + "properties": { 51 51 + "hash": { 52 52 + "type": "string" 53 53 + }, 54 54 + "error": { 55 55 + "type": "string" 56 56 + } 57 57 + } 58 58 + }, 59 59 + "description": "List of changes that failed to apply" 60 60 + }, 61 61 + "newState": { 62 62 + "type": "string", 63 63 + "description": "Pijul channel Merkle state hash after applying changes. Empty string if unavailable." 64 64 + } 65 65 + } 66 66 + } 67 67 + }, 68 68 + "errors": [ 69 69 + { 70 70 + "name": "InvalidRequest" 71 71 + }, 72 72 + { 73 73 + "name": "RepoNotFound" 74 74 + }, 75 75 + { 76 76 + "name": "ChannelNotFound" 77 77 + }, 78 78 + { 79 79 + "name": "ApplyFailed" 80 80 + } 81 81 + ] 82 82 + } 83 83 + } 84 84 + }

+90

lexicons/repo/changeGet.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo.changeGet", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get details of a specific Pijul change", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["repo", "hash"], 11 11 + "properties": { 12 12 + "repo": { 13 13 + "type": "string", 14 14 + "description": "Repository identifier in format 'did:plc:.../repoName'" 15 15 + }, 16 16 + "hash": { 17 17 + "type": "string", 18 18 + "description": "Change hash to retrieve" 19 19 + } 20 20 + } 21 21 + }, 22 22 + "output": { 23 23 + "encoding": "application/json", 24 24 + "schema": { 25 25 + "type": "object", 26 26 + "required": ["hash", "authors", "message"], 27 27 + "properties": { 28 28 + "hash": { 29 29 + "type": "string", 30 30 + "description": "Change hash (base32 encoded)" 31 31 + }, 32 32 + "authors": { 33 33 + "type": "array", 34 34 + "items": { 35 35 + "type": "ref", 36 36 + "ref": "#author" 37 37 + } 38 38 + }, 39 39 + "message": { 40 40 + "type": "string", 41 41 + "description": "Change description" 42 42 + }, 43 43 + "timestamp": { 44 44 + "type": "string", 45 45 + "format": "datetime", 46 46 + "description": "When the change was recorded" 47 47 + }, 48 48 + "dependencies": { 49 49 + "type": "array", 50 50 + "items": { 51 51 + "type": "string" 52 52 + }, 53 53 + "description": "Hashes of changes this change depends on" 54 54 + }, 55 55 + "diff": { 56 56 + "type": "string", 57 57 + "description": "Raw diff content of the change" 58 58 + } 59 59 + } 60 60 + } 61 61 + }, 62 62 + "errors": [ 63 63 + { 64 64 + "name": "RepoNotFound", 65 65 + "description": "Repository not found or access denied" 66 66 + }, 67 67 + { 68 68 + "name": "ChangeNotFound", 69 69 + "description": "Change not found" 70 70 + }, 71 71 + { 72 72 + "name": "InvalidRequest", 73 73 + "description": "Invalid request parameters" 74 74 + } 75 75 + ] 76 76 + }, 77 77 + "author": { 78 78 + "type": "object", 79 79 + "required": ["name"], 80 80 + "properties": { 81 81 + "name": { 82 82 + "type": "string" 83 83 + }, 84 84 + "email": { 85 85 + "type": "string" 86 86 + } 87 87 + } 88 88 + } 89 89 + } 90 90 + }

+122

lexicons/repo/changeList.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo.changeList", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "List changes in a Pijul repository", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["repo"], 11 11 + "properties": { 12 12 + "repo": { 13 13 + "type": "string", 14 14 + "description": "Repository identifier in format 'did:plc:.../repoName'" 15 15 + }, 16 16 + "channel": { 17 17 + "type": "string", 18 18 + "description": "Pijul channel name (defaults to main channel)" 19 19 + }, 20 20 + "limit": { 21 21 + "type": "integer", 22 22 + "description": "Maximum number of changes to return", 23 23 + "minimum": 1, 24 24 + "maximum": 100, 25 25 + "default": 50 26 26 + }, 27 27 + "cursor": { 28 28 + "type": "string", 29 29 + "description": "Pagination cursor (offset)" 30 30 + } 31 31 + } 32 32 + }, 33 33 + "output": { 34 34 + "encoding": "application/json", 35 35 + "schema": { 36 36 + "type": "object", 37 37 + "required": ["changes", "page", "per_page", "total"], 38 38 + "properties": { 39 39 + "changes": { 40 40 + "type": "array", 41 41 + "items": { 42 42 + "type": "ref", 43 43 + "ref": "#changeEntry" 44 44 + } 45 45 + }, 46 46 + "channel": { 47 47 + "type": "string" 48 48 + }, 49 49 + "page": { 50 50 + "type": "integer" 51 51 + }, 52 52 + "per_page": { 53 53 + "type": "integer" 54 54 + }, 55 55 + "total": { 56 56 + "type": "integer" 57 57 + } 58 58 + } 59 59 + } 60 60 + }, 61 61 + "errors": [ 62 62 + { 63 63 + "name": "RepoNotFound", 64 64 + "description": "Repository not found or access denied" 65 65 + }, 66 66 + { 67 67 + "name": "ChannelNotFound", 68 68 + "description": "Channel not found" 69 69 + }, 70 70 + { 71 71 + "name": "InvalidRequest", 72 72 + "description": "Invalid request parameters" 73 73 + } 74 74 + ] 75 75 + }, 76 76 + "changeEntry": { 77 77 + "type": "object", 78 78 + "required": ["hash", "authors", "message"], 79 79 + "properties": { 80 80 + "hash": { 81 81 + "type": "string", 82 82 + "description": "Change hash (base32 encoded)" 83 83 + }, 84 84 + "authors": { 85 85 + "type": "array", 86 86 + "items": { 87 87 + "type": "ref", 88 88 + "ref": "#author" 89 89 + } 90 90 + }, 91 91 + "message": { 92 92 + "type": "string", 93 93 + "description": "Change description" 94 94 + }, 95 95 + "timestamp": { 96 96 + "type": "string", 97 97 + "format": "datetime", 98 98 + "description": "When the change was recorded" 99 99 + }, 100 100 + "dependencies": { 101 101 + "type": "array", 102 102 + "items": { 103 103 + "type": "string" 104 104 + }, 105 105 + "description": "Hashes of changes this change depends on" 106 106 + } 107 107 + } 108 108 + }, 109 109 + "author": { 110 110 + "type": "object", 111 111 + "required": ["name"], 112 112 + "properties": { 113 113 + "name": { 114 114 + "type": "string" 115 115 + }, 116 116 + "email": { 117 117 + "type": "string" 118 118 + } 119 119 + } 120 120 + } 121 121 + } 122 122 + }

+71

lexicons/repo/channelList.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo.channelList", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "List channels in a Pijul repository", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["repo"], 11 11 + "properties": { 12 12 + "repo": { 13 13 + "type": "string", 14 14 + "description": "Repository identifier in format 'did:plc:.../repoName'" 15 15 + }, 16 16 + "limit": { 17 17 + "type": "integer", 18 18 + "description": "Maximum number of channels to return", 19 19 + "minimum": 1, 20 20 + "maximum": 100, 21 21 + "default": 50 22 22 + }, 23 23 + "cursor": { 24 24 + "type": "string", 25 25 + "description": "Pagination cursor (offset)" 26 26 + } 27 27 + } 28 28 + }, 29 29 + "output": { 30 30 + "encoding": "application/json", 31 31 + "schema": { 32 32 + "type": "object", 33 33 + "required": ["channels"], 34 34 + "properties": { 35 35 + "channels": { 36 36 + "type": "array", 37 37 + "items": { 38 38 + "type": "ref", 39 39 + "ref": "#channel" 40 40 + } 41 41 + } 42 42 + } 43 43 + } 44 44 + }, 45 45 + "errors": [ 46 46 + { 47 47 + "name": "RepoNotFound", 48 48 + "description": "Repository not found or access denied" 49 49 + }, 50 50 + { 51 51 + "name": "InvalidRequest", 52 52 + "description": "Invalid request parameters" 53 53 + } 54 54 + ] 55 55 + }, 56 56 + "channel": { 57 57 + "type": "object", 58 58 + "required": ["name"], 59 59 + "properties": { 60 60 + "name": { 61 61 + "type": "string", 62 62 + "description": "Channel name" 63 63 + }, 64 64 + "is_current": { 65 65 + "type": "boolean", 66 66 + "description": "Whether this is the currently active channel" 67 67 + } 68 68 + } 69 69 + } 70 70 + } 71 71 + }

+4

lexicons/repo/create.json

reviewed

··· 34 34 "type": "string", 35 35 "format": "did", 36 36 "description": "Optional user-provided did:web to use as the repo identity instead of minting a did:plc." 37 37 + }, 38 38 + "vcs": { 39 39 + "type": "string", 40 40 + "description": "Version control system to use for the repository (git or pijul)." 37 41 } 38 42 } 39 43 }

+39

lexicons/repo/getDefaultChannel.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo.getDefaultChannel", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get the default channel for a Pijul repository", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["repo"], 11 11 + "properties": { 12 12 + "repo": { 13 13 + "type": "string", 14 14 + "description": "Repository identifier in format 'did:plc:.../repoName'" 15 15 + } 16 16 + } 17 17 + }, 18 18 + "output": { 19 19 + "encoding": "application/json", 20 20 + "schema": { 21 21 + "type": "object", 22 22 + "required": ["channel"], 23 23 + "properties": { 24 24 + "channel": { 25 25 + "type": "string", 26 26 + "description": "Default channel name" 27 27 + } 28 28 + } 29 29 + } 30 30 + }, 31 31 + "errors": [ 32 32 + { 33 33 + "name": "RepoNotFound", 34 34 + "description": "Repository not found or access denied" 35 35 + } 36 36 + ] 37 37 + } 38 38 + } 39 39 + }

+47

lexicons/repo/permissions.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo.permissions", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "parameters": { 8 8 + "type": "params", 9 9 + "required": ["repo"], 10 10 + "properties": { 11 11 + "repo": { 12 12 + "type": "string", 13 13 + "description": "Repository identifier in format 'did:plc:.../repoName'" 14 14 + } 15 15 + } 16 16 + }, 17 17 + "output": { 18 18 + "encoding": "application/json", 19 19 + "schema": { 20 20 + "type": "object", 21 21 + "required": ["permissions", "mask"], 22 22 + "properties": { 23 23 + "permissions": { 24 24 + "type": "array", 25 25 + "items": { 26 26 + "type": "string" 27 27 + } 28 28 + }, 29 29 + "mask": { 30 30 + "type": "integer" 31 31 + } 32 32 + } 33 33 + } 34 34 + }, 35 35 + "errors": [ 36 36 + { 37 37 + "name": "RepoNotFound", 38 38 + "description": "Repository not found or access denied" 39 39 + }, 40 40 + { 41 41 + "name": "InvalidRequest", 42 42 + "description": "Invalid request parameters" 43 43 + } 44 44 + ] 45 45 + } 46 46 + } 47 47 + }

+67

lexicons/repo/pijulBlob.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo.pijulBlob", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get file content from a Pijul repository", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["repo", "path"], 11 11 + "properties": { 12 12 + "repo": { 13 13 + "type": "string", 14 14 + "description": "Repository identifier in format 'did:plc:.../repoName'" 15 15 + }, 16 16 + "channel": { 17 17 + "type": "string", 18 18 + "description": "Pijul channel name (defaults to main channel)" 19 19 + }, 20 20 + "path": { 21 21 + "type": "string", 22 22 + "description": "Path to the file within the repository" 23 23 + } 24 24 + } 25 25 + }, 26 26 + "output": { 27 27 + "encoding": "application/json", 28 28 + "schema": { 29 29 + "type": "object", 30 30 + "required": ["path", "is_binary"], 31 31 + "properties": { 32 32 + "contents": { 33 33 + "type": "string", 34 34 + "description": "File contents (empty for binary files)" 35 35 + }, 36 36 + "is_binary": { 37 37 + "type": "boolean", 38 38 + "description": "Whether the file is binary" 39 39 + }, 40 40 + "path": { 41 41 + "type": "string", 42 42 + "description": "File path" 43 43 + }, 44 44 + "ref": { 45 45 + "type": "string", 46 46 + "description": "Channel name" 47 47 + } 48 48 + } 49 49 + } 50 50 + }, 51 51 + "errors": [ 52 52 + { 53 53 + "name": "RepoNotFound", 54 54 + "description": "Repository not found or access denied" 55 55 + }, 56 56 + { 57 57 + "name": "PathNotFound", 58 58 + "description": "File not found in repository" 59 59 + }, 60 60 + { 61 61 + "name": "InvalidRequest", 62 62 + "description": "Invalid request parameters" 63 63 + } 64 64 + ] 65 65 + } 66 66 + } 67 67 + }

+101

lexicons/repo/pijulTree.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo.pijulTree", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get the file tree from a Pijul repository", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["repo"], 11 11 + "properties": { 12 12 + "repo": { 13 13 + "type": "string", 14 14 + "description": "Repository identifier in format 'did:plc:.../repoName'" 15 15 + }, 16 16 + "channel": { 17 17 + "type": "string", 18 18 + "description": "Pijul channel name (defaults to main channel)" 19 19 + }, 20 20 + "path": { 21 21 + "type": "string", 22 22 + "description": "Path within the repository (defaults to root)", 23 23 + "default": "" 24 24 + } 25 25 + } 26 26 + }, 27 27 + "output": { 28 28 + "encoding": "application/json", 29 29 + "schema": { 30 30 + "type": "object", 31 31 + "required": ["files"], 32 32 + "properties": { 33 33 + "ref": { 34 34 + "type": "string", 35 35 + "description": "Channel name" 36 36 + }, 37 37 + "parent": { 38 38 + "type": "string", 39 39 + "description": "Parent path" 40 40 + }, 41 41 + "dotdot": { 42 42 + "type": "string", 43 43 + "description": "Path to navigate up" 44 44 + }, 45 45 + "files": { 46 46 + "type": "array", 47 47 + "items": { 48 48 + "type": "ref", 49 49 + "ref": "#treeEntry" 50 50 + } 51 51 + }, 52 52 + "readme": { 53 53 + "type": "ref", 54 54 + "ref": "#readme" 55 55 + } 56 56 + } 57 57 + } 58 58 + }, 59 59 + "errors": [ 60 60 + { 61 61 + "name": "RepoNotFound", 62 62 + "description": "Repository not found or access denied" 63 63 + }, 64 64 + { 65 65 + "name": "PathNotFound", 66 66 + "description": "Path not found in repository" 67 67 + }, 68 68 + { 69 69 + "name": "InvalidRequest", 70 70 + "description": "Invalid request parameters" 71 71 + } 72 72 + ] 73 73 + }, 74 74 + "treeEntry": { 75 75 + "type": "object", 76 76 + "required": ["name", "mode", "size"], 77 77 + "properties": { 78 78 + "name": { 79 79 + "type": "string" 80 80 + }, 81 81 + "mode": { 82 82 + "type": "string" 83 83 + }, 84 84 + "size": { 85 85 + "type": "integer" 86 86 + } 87 87 + } 88 88 + }, 89 89 + "readme": { 90 90 + "type": "object", 91 91 + "properties": { 92 92 + "filename": { 93 93 + "type": "string" 94 94 + }, 95 95 + "contents": { 96 96 + "type": "string" 97 97 + } 98 98 + } 99 99 + } 100 100 + } 101 101 + }

+80

lexicons/repo/unrecordChanges.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo.unrecordChanges", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Unrecord (revert) Pijul changes from a repository channel.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["repo", "changes"], 13 13 + "properties": { 14 14 + "repo": { 15 15 + "type": "string", 16 16 + "description": "Repository identifier in format 'did:plc:.../repoName'" 17 17 + }, 18 18 + "channel": { 19 19 + "type": "string", 20 20 + "description": "Target channel to unrecord changes from (optional, uses default if not set)" 21 21 + }, 22 22 + "changes": { 23 23 + "type": "array", 24 24 + "items": { 25 25 + "type": "string" 26 26 + }, 27 27 + "description": "List of change hashes to unrecord" 28 28 + } 29 29 + } 30 30 + } 31 31 + }, 32 32 + "output": { 33 33 + "encoding": "application/json", 34 34 + "schema": { 35 35 + "type": "object", 36 36 + "required": ["unrecorded"], 37 37 + "properties": { 38 38 + "unrecorded": { 39 39 + "type": "array", 40 40 + "items": { 41 41 + "type": "string" 42 42 + }, 43 43 + "description": "List of successfully unrecorded change hashes" 44 44 + }, 45 45 + "failed": { 46 46 + "type": "array", 47 47 + "items": { 48 48 + "type": "object", 49 49 + "required": ["hash", "error"], 50 50 + "properties": { 51 51 + "hash": { 52 52 + "type": "string" 53 53 + }, 54 54 + "error": { 55 55 + "type": "string" 56 56 + } 57 57 + } 58 58 + }, 59 59 + "description": "List of changes that failed to unrecord" 60 60 + } 61 61 + } 62 62 + } 63 63 + }, 64 64 + "errors": [ 65 65 + { 66 66 + "name": "InvalidRequest" 67 67 + }, 68 68 + { 69 69 + "name": "RepoNotFound" 70 70 + }, 71 71 + { 72 72 + "name": "Forbidden" 73 73 + }, 74 74 + { 75 75 + "name": "UnrecordFailed" 76 76 + } 77 77 + ] 78 78 + } 79 79 + } 80 80 + }

+1

nix/modules/knot.nix

reviewed

··· 184 184 config = mkIf cfg.enable { 185 185 environment.systemPackages = [ 186 186 pkgs.git 187 187 + pkgs.pijul 187 188 cfg.package 188 189 ]; 189 190

+2 -1

nix/pkgs/knot.nix

reviewed

··· 2 2 knot-unwrapped, 3 3 makeWrapper, 4 4 git, 5 5 + pijul, 5 6 }: 6 7 knot-unwrapped.overrideAttrs (after: before: { 7 8 nativeBuildInputs = (before.nativeBuildInputs or []) ++ [makeWrapper]; ··· 13 14 cp $GOPATH/bin/knot $out/bin/knot 14 15 15 16 wrapProgram $out/bin/knot \ 16 16 - --prefix PATH : ${git}/bin 17 17 + --prefix PATH : ${git}/bin:${pijul}/bin 17 18 18 19 runHook postInstall 19 20 '';

+8

rbac/permissions.go

reviewed

··· 1 1 + package rbac 2 2 + 3 3 + // Generic repo permissions (VCS-agnostic). 4 4 + const ( 5 5 + RepoCreateDiscussion = "repo:create_discussion" 6 6 + RepoEditDiscussion = "repo:edit_discussion" 7 7 + RepoTagDiscussion = "repo:tag_discussion" 8 8 + )

+6

rbac/rbac.go

reviewed

··· 156 156 {member, domain, repo, "repo:owner"}, 157 157 {member, domain, repo, "repo:invite"}, 158 158 {member, domain, repo, "repo:delete"}, 159 159 + {member, domain, repo, RepoCreateDiscussion}, 160 160 + {member, domain, repo, RepoEditDiscussion}, 161 161 + {member, domain, repo, RepoTagDiscussion}, 159 162 {"server:owner", domain, repo, "repo:delete"}, // server owner can delete any repo 160 163 } 161 164 } ··· 184 187 {collaborator, domain, repo, "repo:collaborator"}, 185 188 {collaborator, domain, repo, "repo:settings"}, 186 189 {collaborator, domain, repo, "repo:push"}, 190 190 + {collaborator, domain, repo, RepoCreateDiscussion}, 191 191 + {collaborator, domain, repo, RepoEditDiscussion}, 192 192 + {collaborator, domain, repo, RepoTagDiscussion}, 187 193 } 188 194 } 189 195 )