Store podcast settings in AT Protocol for persistence

Problem:
- Settings were stored in local file system (podcast-metadata.json)
- File system is ephemeral on Railway - resets on each deployment
- Settings were lost when container restarted

Solution:
- Store settings as AT Protocol record (app.podcast.settings collection)
- Fixed rkey 'self' ensures one settings record per user
- Settings now persist permanently in decentralized storage
- Local file remains as fallback cache

Changes:
- POST /api/feed/metadata now requires auth and stores to ATProto
- GET /api/feed/metadata reads from ATProto first, falls back to local
- RSS generation fetches settings from ATProto
- Settings are truly owned by user and portable

Benefits:
- Settings persist across deployments
- Truly decentralized - user owns their data
- No database needed
- Automatic backup via ATProto

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[e-mail]>

src/routes/feed.js

···
  * Fetches episodes from ATProto collection
  */
 async function generateRSSXML(baseUrl, userDid, rpc) {
-  const feedMeta = await getFeedMetadata();
+  // Try to fetch metadata from AT Protocol first
+  let feedMeta;
+  try {
+    const settingsResult = await ok(
+      rpc.get('com.atproto.repo.getRecord', {
+        params: {
+          repo: userDid,
+          collection: 'app.podcast.settings',
+          rkey: 'self'
+        }
+      })
+    );
+
+    if (settingsResult.value) {
+      feedMeta = {
+        title: settingsResult.value.title,
+        description: settingsResult.value.description,
+        link: settingsResult.value.link,
+        language: settingsResult.value.language
+      };
+    } else {
+      // Fall back to local storage
+      feedMeta = await getFeedMetadata();
+    }
+  } catch (error) {
+    // If not found in ATProto, use local fallback
+    console.log('Settings not found in AT Protocol for RSS generation, using fallback');
+    feedMeta = await getFeedMetadata();
+  }
 
   // Fetch episodes from ATProto collection
   const result = await ok(
···
 /**
  * Update feed metadata
  * POST /api/feed/metadata
+ * Stores metadata in AT Protocol as app.podcast.settings record
  */
-router.post('/metadata', async (req, res) => {
+router.post('/metadata', requireAuth, async (req, res) => {
   try {
     const { title, description, link, language } = req.body;
-    
+    const userDid = req.oauthSession.did;
+
     const feedData = {
       title: title || 'My AT Protocol Podcast',
       description: description || 'A podcast hosted on AT Protocol',
       link: link || 'https://example.com',
       language: language || 'en'
     };
-    
+
+    // Create atcute Client with OAuth session's authenticated fetch handler
+    const rpc = new Client({
+      handler: (pathname, init) => {
+        return req.oauthSession.fetchHandler(pathname, init);
+      }
+    });
+
+    // Store settings in AT Protocol as a record
+    await ok(
+      rpc.post('com.atproto.repo.putRecord', {
+        input: {
+          repo: userDid,
+          collection: 'app.podcast.settings',
+          rkey: 'self', // Fixed key so there's only one settings record
+          record: {
+            $type: 'app.podcast.settings',
+            ...feedData,
+            updatedAt: new Date().toISOString()
+          }
+        }
+      })
+    );
+
+    // Also store locally as fallback
     await storeFeedMetadata(feedData);
-    
+
     res.json({ success: true, feed: feedData });
   } catch (error) {
     console.error('Feed metadata error:', error);
···
 /**
  * Get feed metadata
  * GET /api/feed/metadata
+ * Reads from AT Protocol if authenticated, falls back to local storage
  */
-router.get('/metadata', async (req, res) => {
+router.get('/metadata', requireAuth, async (req, res) => {
   try {
+    const userDid = req.oauthSession.did;
+
+    // Try to fetch from AT Protocol first
+    try {
+      const rpc = new Client({
+        handler: (pathname, init) => {
+          return req.oauthSession.fetchHandler(pathname, init);
+        }
+      });
+
+      const result = await ok(
+        rpc.get('com.atproto.repo.getRecord', {
+          params: {
+            repo: userDid,
+            collection: 'app.podcast.settings',
+            rkey: 'self'
+          }
+        })
+      );
+
+      if (result.value) {
+        const feedMeta = {
+          title: result.value.title,
+          description: result.value.description,
+          link: result.value.link,
+          language: result.value.language
+        };
+
+        // Update local cache
+        await storeFeedMetadata(feedMeta);
+
+        return res.json(feedMeta);
+      }
+    } catch (atprotoError) {
+      // If not found in ATProto, fall through to local storage
+      console.log('Settings not found in AT Protocol, using local fallback');
+    }
+
+    // Fallback to local storage
     const feedMeta = await getFeedMetadata();
     res.json(feedMeta);
   } catch (error) {