add atproto submission to lfm

db/atproto.go

···
 }
 
 // create or update the current user's ATproto session data.
-func (db *DB) SaveATprotoSession(tokenResp *oauth.TokenResponse, authserverIss string, dpopPrivateJWK jwk.Key) error {
-
+func (db *DB) SaveATprotoSession(tokenResp *oauth.TokenResponse, authserverIss string, dpopPrivateJWK jwk.Key, pdsUrl string) error {
+	fmt.Printf("Saving session with PDS url %s", pdsUrl)
 	expiryTime := time.Now().Add(time.Second * time.Duration(tokenResp.ExpiresIn))
 	now := time.Now()
 
···
 			atproto_token_type = ?,
 			atproto_authserver_nonce = ?,
 			atproto_dpop_private_jwk = ?,
+			atproto_pds_url = ?,
+			atproto_pds_nonce = ?,
 			updated_at = ?
 		WHERE atproto_did = ?`,
 		tokenResp.AccessToken,
···
 		tokenResp.TokenType,
 		tokenResp.DpopAuthserverNonce,
 		string(dpopPrivateJWKBytes),
+		pdsUrl,
+		// will get set later
+		"",
 		now,
 		tokenResp.Sub,
 	)
···
 	return nil
 }
 
-func (db *DB) GetAtprotoSession(did string, ctx context.Context, oauthClient oauth.Client) (*oauth.TokenResponse, error) {
-	var oauthSession oauth.TokenResponse
+func (db *DB) GetAtprotoSession(did string, ctx context.Context, oauthClient oauth.Client) (*models.ATprotoAuthSession, error) {
+	var oauthSession models.ATprotoAuthSession
 	var authserverIss string
 	var jwkBytes string
 
 	err := db.QueryRow(`
-		SELECT atproto_access_token, atproto_refresh_token, atproto_token_expiry, atproto_scope, atproto_sub, atproto_authserver_issuer, atproto_token_type, atproto_authserver_nonce, atproto_dpop_private_jwk
+		SELECT id, atproto_did, atproto_pds_url, atproto_authserver_issuer, atproto_access_token, atproto_refresh_token, atproto_pds_nonce, atproto_authserver_nonce, atproto_dpop_private_jwk, atproto_token_expiry
 		FROM users
-		WHERE atproto_did = ?`,
+		WHERE atproto_did = ? OR id`,
 		did,
 	).Scan(
+		&oauthSession.ID,
+		&oauthSession.DID,
+		&oauthSession.PDSUrl,
+		&authserverIss,
 		&oauthSession.AccessToken,
 		&oauthSession.RefreshToken,
-		&oauthSession.ExpiresIn,
-		&oauthSession.Scope,
-		&oauthSession.Sub,
-		&authserverIss,
-		&oauthSession.TokenType,
-		&oauthSession.DpopAuthserverNonce,
+		&oauthSession.DpopPdsNonce,
+		&oauthSession.DpopAuthServerNonce,
 		&jwkBytes,
+		&oauthSession.TokenExpiry,
 	)
 
 	if err != nil {
···
 	privateJwk, err := helpers.ParseJWKFromBytes([]byte(jwkBytes))
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse DPoPPrivateJWK: %w", err)
+	} else {
+		// add jwk to the struct
+		oauthSession.DpopPrivateJWK = privateJwk
 	}
 
+	// printout the session details
+	fmt.Printf("Session details from DB: %+v\n", oauthSession)
+
 	// if token is expired, refresh it
-	if int64(oauthSession.ExpiresIn) < time.Now().Unix() {
+	if time.Now().After(oauthSession.TokenExpiry) {
 
-		resp, err := oauthClient.RefreshTokenRequest(ctx, oauthSession.RefreshToken, authserverIss, oauthSession.DpopAuthserverNonce, privateJwk)
+		resp, err := oauthClient.RefreshTokenRequest(ctx, oauthSession.RefreshToken, authserverIss, oauthSession.DpopAuthServerNonce, privateJwk)
 		if err != nil {
 			return nil, err
 		}
 
-		if err := db.SaveATprotoSession(resp, authserverIss, privateJwk); err != nil {
+		if err := db.SaveATprotoSession(resp, authserverIss, privateJwk, oauthSession.PDSUrl); err != nil {
 			return nil, fmt.Errorf("failed to save refreshed token: %w", err)
 		}
 
-		oauthSession = *resp
+		oauthSession = models.ATprotoAuthSession{
+			ID:                  oauthSession.ID,
+			DID:                 oauthSession.DID,
+			PDSUrl:              oauthSession.PDSUrl,
+			AuthServerIssuer:    authserverIss,
+			AccessToken:         resp.AccessToken,
+			RefreshToken:        resp.RefreshToken,
+			DpopPdsNonce:        oauthSession.DpopPdsNonce,
+			DpopAuthServerNonce: resp.DpopAuthserverNonce,
+			DpopPrivateJWK:      privateJwk,
+			TokenExpiry:         time.Now().Add(time.Duration(resp.ExpiresIn) * time.Second),
+		}
 
 	}
 
 	return &oauthSession, nil
 }
+
+func AtpSessionToAuthArgs(sess *models.ATprotoAuthSession) *oauth.XrpcAuthedRequestArgs {
+	fmt.Printf("DID: %s\nPDS URL: %s\nISS: %s\nAccess Token: %s\nNonce: %s\nPrivate JWK: %s\n", sess.DID, sess.PDSUrl, sess.AuthServerIssuer, sess.AccessToken, sess.DpopPdsNonce, sess.DpopPrivateJWK)
+	return &oauth.XrpcAuthedRequestArgs{
+		Did:            sess.DID,
+		PdsUrl:         sess.PDSUrl,
+		Issuer:         sess.AuthServerIssuer,
+		AccessToken:    sess.AccessToken,
+		DpopPdsNonce:   sess.DpopPdsNonce,
+		DpopPrivateJwk: sess.DpopPrivateJWK,
+	}
+}

db/db.go

···
 		username TEXT,                      -- Made nullable, might not have username initially
 		email TEXT UNIQUE,                  -- Made nullable
 		atproto_did TEXT UNIQUE,            -- Atproto DID (identifier)
+		atproto_pds_url TEXT,
 		atproto_authserver_issuer TEXT,
 		atproto_access_token TEXT,          -- Atproto access token
 		atproto_refresh_token TEXT,         -- Atproto refresh token
···
 		atproto_scope TEXT,                 -- Atproto token scope
 		atproto_token_type TEXT,            -- Atproto token type
 		atproto_authserver_nonce TEXT,
+		atproto_pds_nonce TEXT,
 		atproto_dpop_private_jwk TEXT,
 		spotify_id TEXT UNIQUE,             -- Spotify specific ID
 		access_token TEXT,                  -- Spotify access token
···
 	user := &models.User{}
 
 	err := db.QueryRow(`
-	SELECT id, username, email, spotify_id, access_token, refresh_token, token_expiry, created_at, updated_at
+	SELECT id, username, email, spotify_id, access_token, refresh_token, token_expiry, lastfm_username, created_at, updated_at
 	FROM users WHERE id = ?`, ID).Scan(
 		&user.ID, &user.Username, &user.Email, &user.SpotifyID,
 		&user.AccessToken, &user.RefreshToken, &user.TokenExpiry,
+		&user.LastFMUsername,
 		&user.CreatedAt, &user.UpdatedAt)
 
 	if err == sql.ErrNoRows {
···
 	user := &models.User{}
 
 	err := db.QueryRow(`
-	SELECT id, username, email, spotify_id, access_token, refresh_token, token_expiry, created_at, updated_at
+	SELECT id, username, email, spotify_id, access_token, refresh_token, token_expiry, lastfm_username, created_at, updated_at
 	FROM users WHERE spotify_id = ?`, spotifyID).Scan(
 		&user.ID, &user.Username, &user.Email, &user.SpotifyID,
 		&user.AccessToken, &user.RefreshToken, &user.TokenExpiry,
+		&user.LastFMUsername,
 		&user.CreatedAt, &user.UpdatedAt)
 
 	if err == sql.ErrNoRows {
···
 	return resultMap, nil
 }
 
-func (db *DB) GetLastScrobbleTimestamp(userID int64) (*time.Time, error) {
+func (db *DB) GetLastKnownTimestamp(userID int64) (*time.Time, error) {
 	var lastTimestamp time.Time
 	err := db.QueryRow(`
 		SELECT timestamp

db/lfm.go

···
 
 func (db *DB) GetAllUsersWithLastFM() ([]*models.User, error) {
 	rows, err := db.Query(`
-    SELECT id, username, email, spotify_id, access_token, refresh_token, token_expiry, created_at, updated_at, lastfm_username
+    SELECT id, username, email, lastfm_username
     FROM users
     WHERE lastfm_username IS NOT NULL
     ORDER BY id`)
···
 	for rows.Next() {
 		user := &models.User{}
 		err := rows.Scan(
-			&user.ID, &user.Username, &user.Email, &user.SpotifyID,
-			&user.AccessToken, &user.RefreshToken, &user.TokenExpiry,
-			&user.CreatedAt, &user.UpdatedAt, &user.LastFMUsername)
+			&user.ID, &user.Username, &user.Email, &user.LastFMUsername)
 		if err != nil {
 			return nil, err
 		}
···
 
 func (db *DB) GetUserByLastFM(lastfmUsername string) (*models.User, error) {
 	row := db.QueryRow(`
-    SELECT id, username, email, spotify_id, access_token, refresh_token, token_expiry, created_at, updated_at, lastfm_username
+    SELECT id, username, email, atproto_did, created_at, updated_at, lastfm_username
     FROM users
     WHERE lastfm_username = ?`, lastfmUsername)
 
 	user := &models.User{}
 	err := row.Scan(
-		&user.ID, &user.Username, &user.Email, &user.SpotifyID,
-		&user.AccessToken, &user.RefreshToken, &user.TokenExpiry,
+		&user.ID, &user.Username, &user.Email, &user.ATProtoDID,
 		&user.CreatedAt, &user.UpdatedAt, &user.LastFMUsername)
 	if err != nil {
 		return nil, err

main.go

···
 
 		if isLoggedIn {
 			user, err := database.GetUserByID(userID)
+			fmt.Printf("User: %+v\n", user)
 			if err == nil && user != nil && user.LastFMUsername != nil {
 				lastfmUsername = *user.LastFMUsername
 			} else if err != nil {
···
 
 	mbService := musicbrainz.NewMusicBrainzService(database)
 	spotifyService := spotify.NewSpotifyService(database, atprotoService, mbService)
-	lastfmService := lastfm.NewLastFMService(database, viper.GetString("lastfm.api_key"), mbService)
+	lastfmService := lastfm.NewLastFMService(database, viper.GetString("lastfm.api_key"), mbService, atprotoService)
 
 	sessionManager := session.NewSessionManager(database)
 	oauthManager := oauth.NewOAuthServiceManager(sessionManager)
···
 	trackerInterval := time.Duration(viper.GetInt("tracker.interval")) * time.Second
 	lastfmInterval := time.Duration(viper.GetInt("lastfm.interval_seconds")) * time.Second // Add config for Last.fm interval
 	if lastfmInterval <= 0 {
-		lastfmInterval = 1 * time.Minute
+		lastfmInterval = 30 * time.Second
 	}
 
 	if err := spotifyService.LoadAllUsers(); err != nil {

models/atproto.go

···
 package models
 
 import (
+	"encoding/json"
+	"fmt"
+	"io"
 	"time"
 
 	"github.com/lestrrat-go/jwx/v2/jwk"
+	cbg "github.com/whyrusleeping/cbor-gen"
 )
 
 type ATprotoAuthData struct {
···
 	DPoPPrivateJWK      jwk.Key `json:"dpop_private_jwk"`
 }
 
-type TealFmPlayLexicon struct {
-	Type                  string    `json:"$type"`
-	Duration              int       `json:"duration"`
-	TrackName             string    `json:"trackName"`
-	PlayedTime            time.Time `json:"playedTime"`
-	ArtistMbIDs           []string  `json:"artistMbIds"`
-	ArtistNames           []string  `json:"artistNames"`
-	ReleaseMbID           string    `json:"releaseMbId"`
-	ReleaseName           string    `json:"releaseName"`
-	RecordingMbID         string    `json:"recordingMbId"`
-	SubmissionClientAgent string    `json:"submissionClientAgent"`
+type ATprotoAuthSession struct {
+	ID                  string    `json:"id"`
+	DID                 string    `json:"did"`
+	PDSUrl              string    `json:"pds_url"`
+	AuthServerIssuer    string    `json:"authserver_issuer"`
+	AccessToken         string    `json:"access_token"`
+	RefreshToken        string    `json:"refresh_token"`
+	DpopPdsNonce        string    `json:"dpop_pds_nonce"`
+	DpopAuthServerNonce string    `json:"dpop_authserver_nonce"`
+	DpopPrivateJWK      jwk.Key   `json:"dpop_private_jwk"`
+	TokenExpiry         time.Time `json:"expires_at"`
+}
+
+type TealFmFeedPlay struct {
+	Type                  string   `json:"$type"`
+	Duration              int      `json:"duration"`
+	TrackName             string   `json:"trackName"`
+	PlayedTime            string   `json:"playedTime"`
+	ArtistMbIDs           []string `json:"artistMbIds"`
+	ArtistNames           []string `json:"artistNames"`
+	ReleaseMBID           string   `json:"releaseMbId"`
+	ReleaseName           string   `json:"releaseName"`
+	RecordingMBID         string   `json:"recordingMbId"`
+	SubmissionClientAgent string   `json:"submissionClientAgent"`
+}
+
+func (tfmTrack TealFmFeedPlay) MarshalCBOR(w io.Writer) error {
+	// in case the pointer is nil
+	// if tfmTrack == nil {
+	// 	return fmt.Errorf("cannot marshal nil TealFmFeedPlay")
+	// }
+	fmt.Println("Marshalling", tfmTrack)
+	trackBytes, err := json.Marshal(tfmTrack)
+	if err != nil {
+		return fmt.Errorf("failed to marshal trackMap to bytes: %w", err)
+	}
+
+	cw := cbg.NewCborWriter(w)
+	if err := cbg.WriteByteArray(cw, trackBytes); err != nil {
+		return fmt.Errorf("failed to write bytes as CBOR: %w", err)
+	}
+	return nil
 }

oauth/atproto/atproto.go

···
 	"github.com/lestrrat-go/jwx/v2/jwk"
 	"github.com/teal-fm/piper/db"
 	"github.com/teal-fm/piper/models"
-	// woof
 )
 
 type ATprotoAuthService struct {
-	client   *oauth.Client
-	jwks     jwk.Key
-	DB       *db.DB
-	clientId string
+	client      *oauth.Client
+	jwks        jwk.Key
+	DB          *db.DB
+	clientId    string
+	callbackUrl string
+	xrpc        *oauth.XrpcClient
 }
 
 func NewATprotoAuthService(db *db.DB, jwks jwk.Key, clientId string, callbackUrl string) (*ATprotoAuthService, error) {
···
 	if err != nil {
 		return nil, fmt.Errorf("failed to create atproto oauth client: %w", err)
 	}
-	return &ATprotoAuthService{
-		client:   cli,
-		jwks:     jwks,
-		DB:       db,
-		clientId: clientId,
-	}, nil
+	svc := &ATprotoAuthService{
+		client:      cli,
+		jwks:        jwks,
+		callbackUrl: callbackUrl,
+		DB:          db,
+		clientId:    clientId,
+	}
+	svc.NewXrpcClient()
+	return svc, nil
+}
+
+func (a *ATprotoAuthService) GetATProtoClient() (*oauth.Client, error) {
+	if a.client != nil {
+		return a.client, nil
+	}
+
+	if a.client == nil {
+		cli, err := oauth.NewClient(oauth.ClientArgs{
+			ClientJwk:   a.jwks,
+			ClientId:    a.clientId,
+			RedirectUri: a.callbackUrl,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to create atproto oauth client: %w", err)
+		}
+		a.client = cli
+	}
+
+	return a.client, nil
 }
 
 func LoadJwks(jwksBytes []byte) (jwk.Key, error) {
···
 }
 
 func (a *ATprotoAuthService) getLoginUrlAndSaveState(ctx context.Context, handle string) (*url.URL, error) {
-	scope := "atproto"
+	scope := "atproto transition:generic"
 	// resolve
 	ui, err := a.getUserInformation(ctx, handle)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get user information for %s: %w", handle, err)
 	}
 
+	fmt.Println("user info: ", ui.AuthServer, ui.AuthService)
+
 	// create a dpop jwk for this session
 	k, err := helpers.GenerateKey(nil) // Generate ephemeral DPoP key for this flow
 	if err != nil {
···
 	data := &models.ATprotoAuthData{
 		State:               parResp.State,
 		DID:                 ui.DID,
-		PDSUrl:              ui.AuthServer,
+		PDSUrl:              ui.AuthService,
 		AuthServerIssuer:    ui.AuthMeta.Issuer,
 		PKCEVerifier:        parResp.PkceVerifier,
 		DPoPAuthServerNonce: parResp.DpopAuthserverNonce,
···
 func (a *ATprotoAuthService) HandleCallback(w http.ResponseWriter, r *http.Request) (int64, error) {
 	state := r.URL.Query().Get("state")
 	code := r.URL.Query().Get("code")
-	issuer := r.URL.Query().Get("iss") // Issuer (PDS URL) is needed for token request
+	issuer := r.URL.Query().Get("iss") // Issuer (auth base URL) is needed for token request
 
 	if state == "" || code == "" || issuer == "" {
 		errMsg := r.URL.Query().Get("error")
···
 		return 0, fmt.Errorf("failed to find or create user")
 	}
 
-	err = a.DB.SaveATprotoSession(resp, data.AuthServerIssuer, data.DPoPPrivateJWK)
+	err = a.DB.SaveATprotoSession(resp, data.AuthServerIssuer, data.DPoPPrivateJWK, data.PDSUrl)
 	if err != nil {
 		log.Printf("ATProto Callback Error: Failed to save ATProto tokens for user %d (DID %s): %v", userID.ID, data.DID, err)
 	}

service/lastfm/lastfm.go

···
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"log"
···
 	"sync"
 	"time"
 
+	"github.com/bluesky-social/indigo/api/atproto"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+	"github.com/bluesky-social/indigo/xrpc"
 	"github.com/teal-fm/piper/db"
 	"github.com/teal-fm/piper/models"
+	atprotoauth "github.com/teal-fm/piper/oauth/atproto"
+	"github.com/teal-fm/piper/pkg/lex/teal"
 	"github.com/teal-fm/piper/service/musicbrainz"
 	"golang.org/x/time/rate"
 )
···
 	defaultLimit     = 1 // Default number of tracks to fetch per user
 )
 
-// Structs to represent the Last.fm API response for user.getrecenttracks
-type RecentTracksResponse struct {
-	RecentTracks RecentTracks `json:"recenttracks"`
-}
-
-type RecentTracks struct {
-	Tracks []Track      `json:"track"`
-	Attr   TrackXMLAttr `json:"@attr"`
-}
-
-type Track struct {
-	Artist     Artist     `json:"artist"`
-	Streamable string     `json:"streamable"` // Typically "0" or "1"
-	Image      []Image    `json:"image"`
-	MBID       string     `json:"mbid"` // MusicBrainz ID for the track
-	Album      Album      `json:"album"`
-	Name       string     `json:"name"`
-	URL        string     `json:"url"`
-	Date       *TrackDate `json:"date,omitempty"` // Use pointer for optional fields
-	Attr       *struct {  // Custom handling for @attr.nowplaying
-		NowPlaying string `json:"nowplaying"` // Field name corrected to match struct tag
-	} `json:"@attr,omitempty"` // This captures the @attr object within the track
-}
-
-type Artist struct {
-	MBID string `json:"mbid"` // MusicBrainz ID for the artist
-	Text string `json:"#text"`
-}
-
-type Image struct {
-	Size string `json:"size"`  // "small", "medium", "large", "extralarge"
-	Text string `json:"#text"` // URL of the image
-}
-
-type Album struct {
-	MBID string `json:"mbid"`  // MusicBrainz ID for the album
-	Text string `json:"#text"` // Album name
-}
-
-type TrackDate struct {
-	UTS  string `json:"uts"`   // Unix timestamp string
-	Text string `json:"#text"` // Human-readable date string
-}
-
-type TrackXMLAttr struct {
-	User       string `json:"user"`
-	TotalPages string `json:"totalPages"`
-	Page       string `json:"page"`
-	PerPage    string `json:"perPage"`
-	Total      string `json:"total"`
-}
-
 type LastFMService struct {
 	db                 *db.DB
 	httpClient         *http.Client
···
 	apiKey             string
 	Usernames          []string
 	musicBrainzService *musicbrainz.MusicBrainzService
+	atprotoService     *atprotoauth.ATprotoAuthService
 	lastSeenNowPlaying map[string]Track
 	mu                 sync.Mutex
 }
 
-func NewLastFMService(db *db.DB, apiKey string, musicBrainzService *musicbrainz.MusicBrainzService) *LastFMService {
+func NewLastFMService(db *db.DB, apiKey string, musicBrainzService *musicbrainz.MusicBrainzService, atprotoService *atprotoauth.ATprotoAuthService) *LastFMService {
 	return &LastFMService{
 		db: db,
 		httpClient: &http.Client{
 			Timeout: 10 * time.Second,
 		},
 		// Last.fm unofficial rate limit is ~5 requests per second
-		limiter:   rate.NewLimiter(rate.Every(200*time.Millisecond), 1),
-		apiKey:    apiKey,
-		Usernames: make([]string, 0),
-		// lastSeenTrackDate: make(map[string]time.Time), // Removed
+		limiter:            rate.NewLimiter(rate.Every(200*time.Millisecond), 1),
+		apiKey:             apiKey,
+		Usernames:          make([]string, 0),
+		atprotoService:     atprotoService,
 		musicBrainzService: musicBrainzService,
 		lastSeenNowPlaying: make(map[string]Track),
 		mu:                 sync.Mutex{},
···
 	}
 	usernames := make([]string, len(u))
 	for i, user := range u {
-		// Assuming the User struct has a LastFMUsername field
+		// print out user stuff
 		if user.LastFMUsername != nil { // Check if the username is set
 			usernames[i] = *user.LastFMUsername
 		} else {
 			log.Printf("User ID %d has Last.fm enabled but no username set", user.ID)
-			// Handle this case - maybe skip the user or log differently
 		}
 	}
 
-	// Filter out empty usernames if any were added due to missing data
+	// filter empty usernames (shouldn't happen?)
 	filteredUsernames := make([]string, 0, len(usernames))
 	for _, name := range usernames {
 		if name != "" {
···
 			}
 
 			// Process the fetched tracks
-			if err := l.processTracks(uname, recentTracks.RecentTracks.Tracks); err != nil {
+			if err := l.processTracks(ctx, uname, recentTracks.RecentTracks.Tracks); err != nil {
 				log.Printf("Error processing tracks for %s: %v", uname, err)
 				fetchErrors <- fmt.Errorf("process failed for %s: %w", uname, err) // Report error
 			}
···
 	}
 }
 
-func (l *LastFMService) processTracks(username string, tracks []Track) error {
+func (l *LastFMService) processTracks(ctx context.Context, username string, tracks []Track) error {
 	if l.db == nil {
 		return fmt.Errorf("database connection is nil")
 	}
···
 		return fmt.Errorf("failed to get user ID for %s: %w", username, err)
 	}
 
-	lastKnownTimestamp, err := l.db.GetLastScrobbleTimestamp(user.ID)
+	lastKnownTimestamp, err := l.db.GetLastKnownTimestamp(user.ID)
 	if err != nil {
 		return fmt.Errorf("failed to get last scrobble timestamp for %s: %w", username, err)
 	}
 
-	found := lastKnownTimestamp == nil
-	if found {
+	if lastKnownTimestamp == nil {
 		log.Printf("no previous scrobble timestamp found for user %s. processing latest track.", username)
 	} else {
 		log.Printf("last known scrobble for %s was at %s", username, lastKnownTimestamp.Format(time.RFC3339))
···
 	}
 	latestTrackTime := time.Unix(uts, 0)
 
-	if found && lastKnownTimestamp.Equal(latestTrackTime) {
+	// print both
+	fmt.Printf("latestTrackTime: %s\n", latestTrackTime)
+	fmt.Printf("lastKnownTimestamp: %s\n", lastKnownTimestamp)
+
+	if lastKnownTimestamp != nil && lastKnownTimestamp.Equal(latestTrackTime) {
 		log.Printf("no new tracks to process for user %s.", username)
 		return nil
 	}
···
 		}
 		trackTime := time.Unix(uts, 0)
 
-		if lastKnownTimestamp != nil && trackTime.Before(*lastKnownTimestamp) {
+		// before or at last known
+		if lastKnownTimestamp != nil && (trackTime.Before(*lastKnownTimestamp) || trackTime.Equal(*lastKnownTimestamp)) {
 			if processedCount == 0 {
 				log.Printf("reached already known scrobbles for user %s (track time: %s, last known: %s).",
 					username, trackTime.Format(time.RFC3339), lastKnownTimestamp.Format(time.RFC3339))
···
 			Artist: []models.Artist{
 				{
 					Name: track.Artist.Text,
-					MBID: track.Artist.MBID,
 				},
 			},
+			// this is submitted after the track has been scrobbled on LFM
+			HasStamped: true,
 		}
 
 		hydratedTrack, err := musicbrainz.HydrateTrack(l.musicBrainzService, baseTrack)
 		if err != nil {
 			log.Printf("error hydrating track for user %s: %s - %s: %v", username, track.Artist.Text, track.Name, err)
-			continue
+			// we can use the track without MBIDs, it's still valid
+			hydratedTrack = &baseTrack
 		}
-
 		l.db.SaveTrack(user.ID, hydratedTrack)
+		log.Printf("Submitting track")
+		err = l.SubmitTrackToPDS(*user.ATProtoDID, hydratedTrack, ctx)
+		if err != nil {
+			log.Printf("error submitting track for user %s: %s - %s: %v", username, track.Artist.Text, track.Name, err)
+		}
 		processedCount++
 
 		if trackTime.After(latestProcessedTime) {
 			latestProcessedTime = trackTime
 		}
 
-		if found {
+		if lastKnownTimestamp != nil {
 			break
 		}
 	}
···
 
 	return nil
 }
+
+func (l *LastFMService) SubmitTrackToPDS(did string, track *models.Track, ctx context.Context) error {
+	client, err := l.atprotoService.GetATProtoClient()
+	if err != nil || client == nil {
+		return err
+	}
+
+	xrpcClient := l.atprotoService.GetXrpcClient()
+	if xrpcClient == nil {
+		return errors.New("xrpc client is kil")
+	}
+
+	// we check for client above
+	sess, err := l.db.GetAtprotoSession(did, ctx, *client)
+	if err != nil {
+		return fmt.Errorf("Couldn't get Atproto session: %s", err)
+	}
+
+	// printout the session details
+	fmt.Printf("Session details: %+v\n", sess)
+
+	// horrible no good very bad for now
+	artistArr := []string{}
+	artistMbIdArr := []string{}
+	for _, a := range track.Artist {
+		artistArr = append(artistArr, a.Name)
+		artistMbIdArr = append(artistMbIdArr, a.MBID)
+	}
+
+	var durationPtr *int64
+	if track.DurationMs > 0 {
+		durationSeconds := track.DurationMs / 1000
+		durationPtr = &durationSeconds
+	}
+
+	playedTimeStr := track.Timestamp.Format(time.RFC3339)
+	submissionAgent := "piper/v0.0.1" // TODO: get this from the environment on compilation
+
+	// track -> tealfm track
+	tfmTrack := teal.AlphaFeedPlay{
+		LexiconTypeID: "fm.teal.alpha.feed.play", // Assuming this is the correct Lexicon ID
+		// tfm specifies duration in seconds
+		Duration:  durationPtr, // Pointer required
+		TrackName: track.Name,
+		// should be unix timestamp
+		PlayedTime:            &playedTimeStr,       // Pointer required
+		ArtistNames:           artistArr,            // Slice of strings is correct
+		ArtistMbIds:           artistMbIdArr,        // Slice of strings is correct
+		ReleaseMbId:           &track.ReleaseMBID,   // Pointer required
+		ReleaseName:           &track.Album,         // Pointer required
+		RecordingMbId:         &track.RecordingMBID, // Pointer required
+		SubmissionClientAgent: &submissionAgent,     // Pointer required
+	}
+
+	input := atproto.RepoCreateRecord_Input{
+		Collection: "fm.teal.alpha.feed.play",
+		Repo:       sess.DID,
+		Record:     &lexutil.LexiconTypeDecoder{Val: &tfmTrack},
+	}
+
+	authArgs := db.AtpSessionToAuthArgs(sess)
+	fmt.Println(authArgs)
+
+	var out atproto.RepoCreateRecord_Output
+	if err := xrpcClient.Do(ctx, authArgs, xrpc.Procedure, "application/json", "com.atproto.repo.createRecord", nil, input, &out); err != nil {
+		return err
+	}
+
+	// submit track to PDS
+
+	return nil
+}

service/musicbrainz/musicbrainz.go

···
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		// TODO: Consider reading body for detailed error message from MusicBrainz
+		// TODO: read body for detailed error message
 		return nil, fmt.Errorf("MusicBrainz API request to %s returned status %d", endpoint, resp.StatusCode)
 	}