add a bunch of crap esp. apropos signets

migrations/001_init.up.sql

···
 
 CREATE TABLE signets (
 	uri TEXT PRIMARY KEY,
+	issuer_did TEXT NOT NULL,
 	did TEXT NOT NULL,
 	channel_uri TEXT NOT NULL,
 	FOREIGN KEY (channel_uri) REFERENCES channels(uri) ON DELETE CASCADE,

server/cmd/main.go

···
 	"os"
 	"time"
 	"xcvr-backend/internal/atplistener"
+	"xcvr-backend/internal/atputils"
 	"xcvr-backend/internal/db"
 	"xcvr-backend/internal/handler"
 	"xcvr-backend/internal/log"
···
 		logger.Println("failed to init db")
 		panic(err)
 	}
-	model.Init(store)
+	host, err := atputils.GetPDSFromHandle(context.Background(), atputils.GetMyHandle())
+	if err != nil {
+		panic(err)
+	}
+	did := atputils.GetMyDid()
+	if did == "" {
+		panic(errors.New("WOOPS I MESSED UP THE DID"))
+	}
+	xrpc := oauth.NewPasswordClient(did, host, logger)
+	err = xrpc.CreateSession(context.Background())
+	if err != nil {
+		panic(err)
+	}
+	model := model.Init(store, logger, xrpc)
 	httpclient := &http.Client{
 		Timeout: 5 * time.Second,
 		Transport: &http.Transport{
···
 		logger.Println(err.Error())
 		panic(err)
 	}
-	h := handler.New(store, &logger, oauthclient)
-	go consumeLoop(context.Background(), store, &logger)
+	h := handler.New(store, logger, oauthclient, xrpc, model)
+	go consumeLoop(context.Background(), store, logger)
 	http.ListenAndServe(":8080", h.WithCORSAll())
 
 }

server/go.mod

···
 	github.com/jackc/pgx/v5 v5.7.4
 	github.com/joho/godotenv v1.5.1
 	github.com/lestrrat-go/jwx/v2 v2.0.12
-	github.com/rachel-mp4/lrcd v0.0.0-20250603192958-089ba44e79a5
+	github.com/rachel-mp4/lrcd v0.0.0-20250706133346-685719fb9bfc
+	github.com/rachel-mp4/lrcproto v0.0.0-20250527205756-58da8216f98c
 	github.com/rivo/uniseg v0.4.7
 	github.com/whyrusleeping/cbor-gen v0.3.1
 	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028
···
 	github.com/prometheus/client_model v0.6.1 // indirect
 	github.com/prometheus/common v0.54.0 // indirect
 	github.com/prometheus/procfs v0.15.1 // indirect
-	github.com/rachel-mp4/lrcproto v0.0.0-20250527205756-58da8216f98c // indirect
 	github.com/segmentio/asm v1.2.0 // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
 	gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b // indirect

server/go.sum

···
 github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
 github.com/rachel-mp4/atproto-oauth-golang v0.0.0-20250616212213-a55a5f62b82d h1:FQ8YKfXnKmyEbKnO/blj3qWGhYdw+l3DtQCqSboJRvA=
 github.com/rachel-mp4/atproto-oauth-golang v0.0.0-20250616212213-a55a5f62b82d/go.mod h1:vVRo6BPEmWOZnYk9LtXLzBPzfkY63fUaBahA+o4h55Q=
-github.com/rachel-mp4/lrcd v0.0.0-20250603192958-089ba44e79a5 h1:NMDkC4XYysiYebcoFDnsPdBVr8/NEuahKM6xqQJITp0=
-github.com/rachel-mp4/lrcd v0.0.0-20250603192958-089ba44e79a5/go.mod h1:Hn8xgJ2JwdiFJM5WjamVv4lRTwB6CdcqPjrCvJM7234=
+github.com/rachel-mp4/lrcd v0.0.0-20250706133346-685719fb9bfc h1:JbSq3FHQoEycu/R/ecJoXFeDRGqA2prfsk4cynSbDm0=
+github.com/rachel-mp4/lrcd v0.0.0-20250706133346-685719fb9bfc/go.mod h1:Hn8xgJ2JwdiFJM5WjamVv4lRTwB6CdcqPjrCvJM7234=
 github.com/rachel-mp4/lrcproto v0.0.0-20250527205756-58da8216f98c h1:nOWeKeE7wph0IcwUyUBi0YBynUnAo4JW/J5DM88x4KM=
 github.com/rachel-mp4/lrcproto v0.0.0-20250527205756-58da8216f98c/go.mod h1:hQzO36tQELGbkmRnUtKeM6NMU34t79ZcTlhM+MO7pHw=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=

server/internal/atputils/identity.go

···
 	return *my_handle
 }
 
-func GetMyDid(ctx context.Context) (string, error) {
+func GetMyDid() string {
 	if my_did != nil {
-		return *my_did, nil
+		return *my_did
 	}
 	if my_handle == nil {
 		GetMyHandle()
 	}
-	did, err := GetDidFromHandle(ctx, *my_handle)
+	did, err := GetDidFromHandle(context.Background(), *my_handle)
 	if err != nil {
-		return "", err
+		return ""
 	}
 	my_did = &did
-	return did, nil
+	return did
 }
 
 func GetHandleFromDid(ctx context.Context, did string) (string, error) {

server/internal/db/db.go

···
 	}
 	return chans, nil
 }
+
+func (s *Store) DeleteChannel(uri string, ctx context.Context) error {
+	_, err := s.pool.Exec(ctx, `DELETE FROM channels WHERE uri = $1`, uri)
+	return err
+}

server/internal/db/lexicon.go

···
 		`, channel.URI, channel.CID, channel.DID, channel.Host, channel.Title, channel.Topic, channel.CreatedAt)
 	return err
 }
+
+func (s *Store) StoreMessage(message types.Message, ctx context.Context) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO messages (
+		  uri,
+			cid,
+			did,
+			signet_uri,
+			body,
+			nick,
+			color,
+			posted_at
+		) VALUES (
+			$1, $2, $3, $4, $5, $6, $7, $8
+		) ON CONFLICT (uri) DO NOTHING
+		`, message.URI, message.CID, message.DID, message.SignetURI, message.Body, message.Nick, message.Color, message.PostedAt)
+	return err
+}
+
+func (s *Store) QuerySignet(channelUri string, id uint32, ctx context.Context) (string, error) {
+	row := s.pool.QueryRow(ctx, `SELECT s.uri FROM signets s WHERE s.channel_uri = $1 AND s.message_id = $2`, channelUri, id)
+	var signetUri string
+	err := row.Scan(&signetUri)
+	if err != nil {
+		return "", errors.New("error scanning: " + err.Error())
+	}
+	return signetUri, nil
+}
+
+func (s *Store) StoreSignet(signet types.Signet, ctx context.Context) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO signets (
+			uri,
+			issuer_did,
+			did,
+			channel_uri,
+			message_id,
+			cid,
+			started_at
+		) VALUES (
+		$1, $2, $3, $4, $5, $6, %7
+		) ON CONFLICT (uri) DO NOTHING
+		`, signet.URI, signet.IssuerDID, signet.DID, signet.ChannelURI, signet.MessageID, signet.CID, signet.StartedAt)
+	if err != nil {
+		err = errors.New("SOMETHING BAD HAPPENED: " + err.Error())
+	}
+	return err
+}

server/internal/handler/handler.go

···
 package handler
 
 import (
-	"context"
 	"github.com/gorilla/sessions"
 	"net/http"
 
 	"os"
-	"xcvr-backend/internal/atputils"
 	"xcvr-backend/internal/db"
-	"xcvr-backend/internal/lex"
 	"xcvr-backend/internal/log"
+	"xcvr-backend/internal/model"
 	"xcvr-backend/internal/oauth"
 )
 
···
 	oauth        *oauth.Service
 	myClient     *oauth.PasswordClient
 	clientmap    *oauth.ClientMap
+	model        *model.Model
 }
 
-func New(db *db.Store, logger *log.Logger, oauthserv *oauth.Service) *Handler {
+func New(db *db.Store, logger *log.Logger, oauthserv *oauth.Service, xrpc *oauth.PasswordClient, model *model.Model) *Handler {
 	mux := http.NewServeMux()
 	sessionStore := sessions.NewCookieStore([]byte(os.Getenv("SESSION_KEY")))
-	host, err := atputils.GetPDSFromHandle(context.Background(), atputils.GetMyHandle())
-	if err != nil {
-		panic(err)
-	}
-	did, err := atputils.GetMyDid(context.Background())
-	if err != nil {
-		panic(err)
-	}
-	xrpc := oauth.NewPasswordClient(did, host, logger)
-	err = xrpc.CreateSession(context.Background())
-	if err != nil {
-		panic(err)
-	}
-	_, _, err = xrpc.CreateXCVRSignet(&lex.SignetRecord{
-		ChannelURI: "beep.boop",
-		LRCID:      11,
-		Author:     "sneep.snirp",
-	}, context.Background())
-	if err != nil {
-		panic(err)
-	}
 	clientmap := oauth.NewClientMap()
-	h := &Handler{db, sessionStore, mux, logger, oauthserv, xrpc, clientmap}
+	h := &Handler{db, sessionStore, mux, logger, oauthserv, xrpc, clientmap, model}
 	// lrc handlers
 	mux.HandleFunc("GET /lrc/{user}/{rkey}/ws", h.acceptWebsocket)
+	mux.HandleFunc("DELETE /lrc/{user}/{rkey}/ws", h.deleteChannel)
 	mux.HandleFunc("POST /lrc/channel", h.postChannel)
 	mux.HandleFunc("POST /lrc/message", h.postMessage)
 	// beep handlers

server/internal/handler/lrcHandlers.go

···
 	"fmt"
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"net/http"
+	"os"
 	"time"
 	"xcvr-backend/internal/atputils"
 	"xcvr-backend/internal/lex"
-	"xcvr-backend/internal/model"
 	"xcvr-backend/internal/types"
 )
 
···
 	rkey := r.PathValue("rkey")
 	user := r.PathValue("user")
 	uri := fmt.Sprintf("at://%s/org.xcvr.feed.channel/%s", user, rkey)
-	f, err := model.GetWSHandlerFrom(uri)
+	f, err := h.model.GetWSHandlerFrom(uri)
 	if err != nil {
 		http.NotFound(w, r)
 		h.logger.Deprintf("couldn't find user %s's server %s", user, rkey)
···
 		h.serverError(w, err)
 		return
 	}
-	mydid, err := atputils.GetMyDid(r.Context())
-	if err != nil {
-		h.serverError(w, err)
-		return
-	}
 	channel := types.Channel{
 		URI:       uri,
 		CID:       cid,
-		DID:       mydid,
+		DID:       atputils.GetMyDid(),
 		Host:      lcr.Host,
 		Title:     lcr.Title,
 		Topic:     lcr.Topic,
···
 
 }
 
+func (h *Handler) parseMessageRequest(r *http.Request) (*lex.MessageRecord, *time.Time, error) {
+	var mr types.PostMessageRequest
+	decoder := json.NewDecoder(r.Body)
+	err := decoder.Decode(&mr)
+	if err != nil {
+		return nil, nil, errors.New("couldn't decode: " + err.Error())
+	}
+	if mr.SignetURI == nil {
+		if mr.MessageID == nil || mr.ChannelURI == nil {
+			return nil, nil, errors.New("must provide a way to determine signet")
+		}
+		signetUri, err := h.db.QuerySignet(*mr.ChannelURI, *mr.MessageID, r.Context())
+		if err != nil {
+			return nil, nil, errors.New("i couldn't find the signet :c : " + err.Error())
+		}
+		mr.SignetURI = &signetUri
+	}
+	var lmr lex.MessageRecord
+	lmr.SignetURI = *mr.SignetURI
+	lmr.Body = mr.Body
+	if mr.Nick != nil {
+		nick := *mr.Nick
+		if atputils.ValidateLength(nick, 16) {
+			return nil, nil, errors.New("that nick is too long")
+		}
+	}
+	lmr.Nick = mr.Nick
+
+	if mr.Color != nil {
+		color := uint64(*mr.Color)
+		if color > 16777215 {
+			return nil, nil, errors.New("that color is too big")
+		}
+	}
+	now := syntax.DatetimeNow()
+	lmr.PostedAt = now.String()
+	nt := now.Time()
+	return &lmr, &nt, nil
+}
+
+func (h *Handler) postMyMessage(w http.ResponseWriter, r *http.Request) {
+
+}
+
 func (h *Handler) postMessage(w http.ResponseWriter, r *http.Request) {
+	session, _ := h.sessionStore.Get(r, "oauthsession")
+	_, ok := session.Values["id"].(uint)
+	if !ok {
+		h.postMyMessage(w, r)
+		return
+	}
+	client, err := h.getClient(r)
+	if err != nil {
+		h.serverError(w, errors.New("couldn't find client: "+err.Error()))
+		return
+	}
 
+	lmr, now, err := h.parseMessageRequest(r)
+	if err != nil {
+		h.badRequest(w, errors.New("couldn't parse message "+err.Error()))
+		return
+	}
+
+	uri, cid, err := client.CreateXCVRMessage(*lmr, r.Context())
+	if err != nil {
+		h.serverError(w, errors.New("couldn't add to user repo: "))
+		return
+	}
+	did := session.Values["did"].(string)
+	var coloruint32ptr *uint32
+	if lmr.Color != nil {
+		color := uint32(*lmr.Color)
+		coloruint32ptr = &color
+	}
+	message := types.Message{
+		URI:       uri,
+		DID:       did,
+		CID:       cid,
+		SignetURI: lmr.SignetURI,
+		Body:      lmr.Body,
+		Nick:      lmr.Nick,
+		Color:     coloruint32ptr,
+		PostedAt:  *now,
+	}
+	err = h.db.StoreMessage(message, r.Context())
+	if err != nil {
+		h.serverError(w, errors.New("sooo... the record posted but i couldn't store it: "+err.Error()))
+		return
+	}
+	h.getMessages(w, r)
+}
+
+func (h *Handler) deleteChannel(w http.ResponseWriter, r *http.Request) {
+	did, handle, err := h.findDidAndHandle(r)
+	if err != nil {
+		return
+	}
+	rkey := r.PathValue("rkey")
+	user := r.PathValue("user")
+	if did != user && handle != os.Getenv("ADMIN_HANDLE") {
+		return
+	}
+	uri := fmt.Sprintf("at://%s/org.xcvr.feed.channel/%s", user, rkey)
+	err = h.db.DeleteChannel(uri, r.Context())
+	if err != nil {
+		return
+	}
+	h.getChannels(w, r)
 }

server/internal/log/log.go

···
 	Slog        *slog.Logger
 }
 
-func New(w io.Writer, verbose bool) Logger {
+func New(w io.Writer, verbose bool) *Logger {
 	l := Logger{}
 	l.prodLogger = log.New(w, "[log]", log.Ldate|log.Ltime)
 	if verbose {
 		l.debugLogger = log.New(w, "[debug]", log.Ldate|log.Ltime)
 	}
 	l.Slog = slog.New(slog.NewTextHandler(w, nil))
-	return l
+	return &l
 }
 
 func (l *Logger) Deprintln(s string) {
···
 func (l *Logger) Printf(format string, args ...any) {
 	l.Println(fmt.Sprintf(format, args...))
 }
-

server/internal/model/channel.go

···
 import (
 	"context"
 	"errors"
+	"github.com/bluesky-social/indigo/atproto/syntax"
 	"net/http"
 	"os"
+	"sync"
+	"time"
+	"xcvr-backend/internal/atputils"
 	"xcvr-backend/internal/db"
+	"xcvr-backend/internal/lex"
+	"xcvr-backend/internal/log"
+	"xcvr-backend/internal/oauth"
+	"xcvr-backend/internal/types"
 
 	"github.com/rachel-mp4/lrcd"
+	lrcpb "github.com/rachel-mp4/lrcproto/gen/go"
 )
 
-var (
-	validServer map[string]bool
-	uriToServer = make(map[string]*lrcd.Server)
-)
+type Model struct {
+	store  *db.Store
+	uriMap map[string]*serverModel
+	logger *log.Logger
+	cli    *oauth.PasswordClient
+	mu     sync.Mutex
+}
 
-func GetWSHandlerFrom(uri string) (http.HandlerFunc, error) {
-	server, err := getServer(uri)
+type serverModel struct {
+	valid      bool
+	server     *lrcd.Server
+	lastID     uint32
+	initChan   chan lrcpb.Event_Init
+	cancelFunc func()
+}
+
+func (m *Model) GetWSHandlerFrom(uri string) (http.HandlerFunc, error) {
+	server, err := m.getServer(uri)
 	if err != nil {
 		return nil, err
 	}
 	return server.WSHandler(), nil
 }
 
-func Init(store *db.Store) {
+func Init(store *db.Store, logger *log.Logger, cli *oauth.PasswordClient) *Model {
 	uris, err := store.GetChannelURIs(context.Background())
 	if err != nil {
 		panic(err)
 	}
-	validServer = make(map[string]bool, len(uris))
+	uriToServerModel := make(map[string]*serverModel, len(uris))
 	myid := os.Getenv("MY_IDENTITY")
 	for _, uri := range uris {
-		validServer[uri.URI] = (uri.Host == myid)
+		valid := (uri.Host == myid)
+		beep := serverModel{valid: valid}
+		uriToServerModel[uri.URI] = &beep
+	}
+	return &Model{
+		store,
+		uriToServerModel,
+		logger,
+		cli,
+		sync.Mutex{},
 	}
 }
 
-func getServer(uri string) (*lrcd.Server, error) {
-	if !validServer[uri] {
+func (m *Model) getServer(uri string) (*lrcd.Server, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	sm := m.uriMap[uri]
+	if sm == nil {
 		return nil, errors.New("Not a valid server")
 	}
-	server, ok := uriToServer[uri]
-	if !ok {
+	if !sm.valid {
+		return nil, errors.New("Not hosted on this backend!")
+	}
+
+	if sm.server == nil {
 		var err error
-		server, err = lrcd.NewServer(lrcd.WithLogging(os.Stdout,true))
+		lastID := sm.lastID
+		initChan := make(chan lrcpb.Event_Init, 100)
+
+		server, err := lrcd.NewServer(
+			lrcd.WithLogging(os.Stdout, true),
+			lrcd.WithInitialID(lastID),
+			lrcd.WithInitChannel(initChan),
+		)
 		if err != nil {
 			return nil, errors.New("Error creating server")
 		}
-		uriToServer[uri] = server
+
 		err = server.Start()
 		if err != nil {
 			return nil, errors.New("Error starting server")
 		}
+
+		if sm.cancelFunc != nil {
+			sm.cancelFunc()
+		}
+
+		ctx, cancel := context.WithCancel(context.Background())
+		sm.server = server
+		sm.initChan = initChan
+		sm.cancelFunc = cancel
+
+		go m.handleInitEvents(ctx, uri, initChan)
 	}
-	return server, nil
+	return sm.server, nil
 }
 
+func (m *Model) handleInitEvents(ctx context.Context, uri string, initChan <-chan lrcpb.Event_Init) {
+	ticker := time.NewTicker(5 * time.Minute)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			m.mu.Lock()
+			sm := m.uriMap[uri]
+			if sm == nil || sm.server == nil {
+				m.mu.Unlock()
+				return
+			}
+
+			c := sm.server.Connected()
+			if c == 0 {
+				lastID, err := sm.server.Stop()
+				if err != nil {
+					m.mu.Unlock()
+					panic(err)
+				}
+				sm.lastID = lastID
+				sm.server = nil
+				sm.initChan = nil
+				m.mu.Unlock()
+				return
+			}
+			m.mu.Unlock()
+		case e, ok := <-initChan:
+			if !ok {
+				return
+			}
+			signet := lex.SignetRecord{}
+			handle := e.Init.ExternalID
+			if handle == nil {
+				h := ""
+				handle = &h
+			}
+			signet.Author = *handle
+			if e.Init.Id == nil {
+				m.logger.Deprintln("initchannel gave me a nil id")
+				continue
+			}
+			lrcid := uint64(*e.Init.Id)
+			signet.LRCID = lrcid
+			signet.ChannelURI = uri
+			now := syntax.DatetimeNow()
+			nowTime := now.Time()
+			nowString := now.String()
+			signet.StartedAt = &nowString
+			cid, recorduri, err := m.cli.CreateXCVRSignet(&signet, context.Background())
+			if err != nil {
+				m.logger.Deprintf("couldn't post a signet in %s: %s", uri, err.Error())
+				continue
+			}
+			sr := types.Signet{
+				URI:        recorduri,
+				IssuerDID:  atputils.GetMyDid(),
+				DID:        signet.Author,
+				ChannelURI: uri,
+				MessageID:  *e.Init.Id,
+				CID:        cid,
+				StartedAt:  nowTime,
+			}
+			err = m.store.StoreSignet(sr, context.Background())
+			if err != nil {
+				m.logger.Println("failed to store signet!")
+			}
+		}
+	}
+}

server/internal/oauth/oauthclient.go

···
 	return
 }
 
-func (c *OauthXRPCClient) CreateXCVRMessage(message lex.MessageRecord, ctx context.Context) error {
+func (c *OauthXRPCClient) CreateXCVRMessage(message lex.MessageRecord, ctx context.Context) (uri string, cid string, err error) {
 	authargs, err := c.getOauthSessionAuthArgs()
 	if err != nil {
-		return errors.New("uh oh... I couldn't make a XCVRMessage: " + err.Error())
+		err = errors.New("uh oh... I couldn't make a XCVRMessage: " + err.Error())
+		return
 	}
 	input := atproto.RepoCreateRecord_Input{
 		Collection: "org.xcvr.lrc.message",
···
 	var out atproto.RepoCreateRecord_Output
 	err = c.xrpc.Do(ctx, authargs, "POST", "application/json", "com.atproto.repo.createRecord", nil, input, &out)
 	if err != nil {
-		return errors.New("i've got a bad feeling aobut this... failed to create XCVRMessage: " + err.Error())
+		err = errors.New("i've got a bad feeling aobut this... failed to create XCVRMessage: " + err.Error())
+		return
 	}
-	return nil
+	uri = out.Uri
+	cid = out.Cid
+	return
 }
 
 func (c *OauthXRPCClient) UpdateXCVRProfile(profile lex.ProfileRecord, ctx context.Context) error {

server/internal/types/lexicons.go

···
 
 type Signet struct {
 	URI        string
+	IssuerDID  string
 	DID        string
 	ChannelURI string
 	MessageID  uint32
···
 	DID       string
 	SignetURI string
 	Body      string
-	Nick      string
-	Color     uint32
+	Nick      *string
+	Color     *uint32
 	CID       string
 	PostedAt  time.Time
 	IndexedAt time.Time
+}
+
+type PostMessageRequest struct {
+	SignetURI  *string `json:"signetURI,omitempty"`
+	ChannelURI *string `json:"channelURI,omitempty"`
+	MessageID  *uint32 `json:"messageID,omitempty"`
+	Body       string  `json:"body"`
+	Nick       *string `json:"nick,omitempty"`
+	Color      *uint32 `json:"color,omitempty"`
 }
 
 type MessageView struct {