update submission client name

atproto.js

···
 class ATProtoClient {
   constructor() {
     this.session = null;
-    this.pds = 'https://bsky.social';
+    this.pds = "https://bsky.social";
   }
 
   async login(identifier, password, pdsUrl) {
···
         await chrome.storage.local.set({ pdsUrl });
       }
 
-      const response = await fetch(`${this.pds}/xrpc/com.atproto.server.createSession`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          identifier,
-          password,
-        }),
-      });
+      const response = await fetch(
+        `${this.pds}/xrpc/com.atproto.server.createSession`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            identifier,
+            password,
+          }),
+        }
+      );
 
       if (!response.ok) {
         throw new Error(`Login failed: ${response.statusText}`);
···
 
       return this.session;
     } catch (error) {
-      console.error('AT Proto login error:', error);
+      console.error("AT Proto login error:", error);
       throw error;
     }
   }
 
   async loadSession() {
-    const data = await chrome.storage.local.get(['atprotoSession', 'pdsUrl']);
+    const data = await chrome.storage.local.get(["atprotoSession", "pdsUrl"]);
     if (data.pdsUrl) {
       this.pds = data.pdsUrl;
     }
···
 
   async logout() {
     this.session = null;
-    await chrome.storage.local.remove('atprotoSession');
+    await chrome.storage.local.remove("atprotoSession");
   }
 
   async createScrobbleRecord(trackInfo) {
     if (!this.session) {
-      throw new Error('Not authenticated');
+      throw new Error("Not authenticated");
     }
 
     // Build the teal.fm play record
     const record = {
-      $type: 'fm.teal.alpha.feed.play',
+      $type: "fm.teal.alpha.feed.play",
       trackName: trackInfo.track,
       playedTime: new Date(trackInfo.timestamp).toISOString(),
-      submissionClientAgent: 'fm.teal.nts-scrobbler/1.0.0',
-      musicServiceBaseDomain: 'nts.live'
+      submissionClientAgent: "nts-teal-piper/1.0.0",
+      musicServiceBaseDomain: "nts.live",
     };
 
     // Add MusicBrainz metadata if available
···
 
     // Fallback: if no MusicBrainz artists, use basic artist info
     if (!record.artists && trackInfo.artist) {
-      record.artists = [{
-        artistName: trackInfo.artist
-      }];
+      record.artists = [
+        {
+          artistName: trackInfo.artist,
+        },
+      ];
     }
 
     // Add optional fields
···
     }
 
     try {
-      const response = await fetch(`${this.pds}/xrpc/com.atproto.repo.createRecord`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${this.session.accessJwt}`,
-        },
-        body: JSON.stringify({
-          repo: this.session.did,
-          collection: 'fm.teal.alpha.feed.play',
-          record,
-        }),
-      });
+      const response = await fetch(
+        `${this.pds}/xrpc/com.atproto.repo.createRecord`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.session.accessJwt}`,
+          },
+          body: JSON.stringify({
+            repo: this.session.did,
+            collection: "fm.teal.alpha.feed.play",
+            record,
+          }),
+        }
+      );
 
       if (!response.ok) {
         const errorText = await response.text();
-        throw new Error(`Failed to create record: ${response.statusText} - ${errorText}`);
+        throw new Error(
+          `Failed to create record: ${response.statusText} - ${errorText}`
+        );
       }
 
       return await response.json();
     } catch (error) {
-      console.error('Error creating scrobble record:', error);
+      console.error("Error creating scrobble record:", error);
       throw error;
     }
   }
 
   async refreshSession() {
     if (!this.session?.refreshJwt) {
-      throw new Error('No refresh token available');
+      throw new Error("No refresh token available");
     }
 
     try {
-      const response = await fetch(`${this.pds}/xrpc/com.atproto.server.refreshSession`, {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${this.session.refreshJwt}`,
-        },
-      });
+      const response = await fetch(
+        `${this.pds}/xrpc/com.atproto.server.refreshSession`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.session.refreshJwt}`,
+          },
+        }
+      );
 
       if (!response.ok) {
-        throw new Error('Session refresh failed');
+        throw new Error("Session refresh failed");
       }
 
       this.session = await response.json();
···
 
       return this.session;
     } catch (error) {
-      console.error('Session refresh error:', error);
+      console.error("Session refresh error:", error);
       throw error;
     }
   }
···
 }
 
 // Make available to other scripts
-if (typeof module !== 'undefined' && module.exports) {
+if (typeof module !== "undefined" && module.exports) {
   module.exports = ATProtoClient;
 }