linting

netlify/functions/batch-follow-users.ts

···
-import { Handler, HandlerEvent, HandlerResponse } from '@netlify/functions';
-import { NodeOAuthClient, atprotoLoopbackClientMetadata } from '@atproto/oauth-client-node';
-import { JoseKey } from '@atproto/jwk-jose';
-import { stateStore, sessionStore, userSessions } from './oauth-stores-db';
-import { getOAuthConfig } from './oauth-config';
-import { Agent } from '@atproto/api';
-import cookie from 'cookie';
+import { Handler, HandlerEvent, HandlerResponse } from "@netlify/functions";
+import {
+  NodeOAuthClient,
+  atprotoLoopbackClientMetadata,
+} from "@atproto/oauth-client-node";
+import { JoseKey } from "@atproto/jwk-jose";
+import { stateStore, sessionStore, userSessions } from "./oauth-stores-db";
+import { getOAuthConfig } from "./oauth-config";
+import { Agent } from "@atproto/api";
+import cookie from "cookie";
 
 function normalizePrivateKey(key: string): string {
-  if (!key.includes('\n') && key.includes('\\n')) {
-    return key.replace(/\\n/g, '\n');
+  if (!key.includes("\n") && key.includes("\\n")) {
+    return key.replace(/\\n/g, "\n");
   }
   return key;
 }
 
-export const handler: Handler = async (event: HandlerEvent): Promise<HandlerResponse> => {
+export const handler: Handler = async (
+  event: HandlerEvent,
+): Promise<HandlerResponse> => {
   // Only allow POST
-  if (event.httpMethod !== 'POST') {
+  if (event.httpMethod !== "POST") {
     return {
       statusCode: 405,
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ error: 'Method not allowed' }),
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ error: "Method not allowed" }),
     };
   }
 
   try {
     // Parse request body
-    const body = JSON.parse(event.body || '{}');
+    const body = JSON.parse(event.body || "{}");
     const dids: string[] = body.dids || [];
 
     if (!Array.isArray(dids) || dids.length === 0) {
       return {
         statusCode: 400,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'dids array is required and must not be empty' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          error: "dids array is required and must not be empty",
+        }),
       };
     }
 
···
     if (dids.length > 100) {
       return {
         statusCode: 400,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'Maximum 100 DIDs per batch' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Maximum 100 DIDs per batch" }),
       };
     }
 
     // Get session from cookie
-    const cookies = event.headers.cookie ? cookie.parse(event.headers.cookie) : {};
+    const cookies = event.headers.cookie
+      ? cookie.parse(event.headers.cookie)
+      : {};
     const sessionId = cookies.atlast_session;
 
     if (!sessionId) {
       return {
         statusCode: 401,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'No session cookie' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "No session cookie" }),
       };
     }
 
···
     if (!userSession) {
       return {
         statusCode: 401,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'Invalid or expired session' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Invalid or expired session" }),
       };
     }
 
     const config = getOAuthConfig();
-    const isDev = config.clientType === 'loopback';
+    const isDev = config.clientType === "loopback";
 
     let client: NodeOAuthClient;
 
···
     } else {
       // Production with private key
       const normalizedKey = normalizePrivateKey(process.env.OAUTH_PRIVATE_KEY!);
-      const privateKey = await JoseKey.fromImportable(normalizedKey, 'main-key');
+      const privateKey = await JoseKey.fromImportable(
+        normalizedKey,
+        "main-key",
+      );
 
       client = new NodeOAuthClient({
         clientMetadata: {
           client_id: config.clientId,
-          client_name: 'ATlast',
-          client_uri: config.clientId.replace('/client-metadata.json', ''),
+          client_name: "ATlast",
+          client_uri: config.clientId.replace("/client-metadata.json", ""),
           redirect_uris: [config.redirectUri],
-          scope: 'atproto transition:generic',
-          grant_types: ['authorization_code', 'refresh_token'],
-          response_types: ['code'],
-          application_type: 'web',
-          token_endpoint_auth_method: 'private_key_jwt',
-          token_endpoint_auth_signing_alg: 'ES256',
+          scope: "atproto transition:generic",
+          grant_types: ["authorization_code", "refresh_token"],
+          response_types: ["code"],
+          application_type: "web",
+          token_endpoint_auth_method: "private_key_jwt",
+          token_endpoint_auth_signing_alg: "ES256",
           dpop_bound_access_tokens: true,
           jwks_uri: config.jwksUri,
         },
···
 
     // Restore OAuth session
     const oauthSession = await client.restore(userSession.did);
-    
+
     // Create agent from OAuth session
     const agent = new Agent(oauthSession);
 
···
     const results = [];
     let consecutiveErrors = 0;
     const MAX_CONSECUTIVE_ERRORS = 3;
-    
+
     for (const did of dids) {
       try {
         await agent.api.com.atproto.repo.createRecord({
           repo: userSession.did,
-          collection: 'app.bsky.graph.follow',
+          collection: "app.bsky.graph.follow",
           record: {
-            $type: 'app.bsky.graph.follow',
+            $type: "app.bsky.graph.follow",
             subject: did,
             createdAt: new Date().toISOString(),
           },
         });
-        
+
         results.push({
           did,
           success: true,
-          error: null
+          error: null,
         });
-        
+
         // Reset error counter on success
         consecutiveErrors = 0;
       } catch (error) {
         consecutiveErrors++;
-        
+
         results.push({
           did,
           success: false,
-          error: error instanceof Error ? error.message : 'Follow failed'
+          error: error instanceof Error ? error.message : "Follow failed",
         });
-        
+
         // If we hit rate limits, implement exponential backoff
-        if (error instanceof Error && 
-            (error.message.includes('rate limit') || error.message.includes('429'))) {
-          const backoffDelay = Math.min(200 * Math.pow(2, consecutiveErrors), 2000);
+        if (
+          error instanceof Error &&
+          (error.message.includes("rate limit") ||
+            error.message.includes("429"))
+        ) {
+          const backoffDelay = Math.min(
+            200 * Math.pow(2, consecutiveErrors),
+            2000,
+          );
           console.log(`Rate limit hit. Backing off for ${backoffDelay}ms...`);
-          await new Promise(resolve => setTimeout(resolve, backoffDelay));
+          await new Promise((resolve) => setTimeout(resolve, backoffDelay));
         } else if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
           // For other repeated errors, small backoff
-          await new Promise(resolve => setTimeout(resolve, 500));
+          await new Promise((resolve) => setTimeout(resolve, 500));
         }
       }
     }
 
-    const successCount = results.filter(r => r.success).length;
-    const failCount = results.filter(r => !r.success).length;
+    const successCount = results.filter((r) => r.success).length;
+    const failCount = results.filter((r) => !r.success).length;
 
     return {
       statusCode: 200,
       headers: {
-        'Content-Type': 'application/json',
-        'Access-Control-Allow-Origin': '*',
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
       },
       body: JSON.stringify({
         success: true,
         total: dids.length,
         succeeded: successCount,
         failed: failCount,
-        results
+        results,
       }),
     };
-
   } catch (error) {
-    console.error('Batch follow error:', error);
+    console.error("Batch follow error:", error);
     return {
       statusCode: 500,
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ 
-        error: 'Failed to follow users',
-        details: error instanceof Error ? error.message : 'Unknown error'
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        error: "Failed to follow users",
+        details: error instanceof Error ? error.message : "Unknown error",
       }),
     };
   }
-};
+};

netlify/functions/batch-search-actors.ts

···
-import { Handler, HandlerEvent, HandlerResponse } from '@netlify/functions';
-import { NodeOAuthClient, atprotoLoopbackClientMetadata } from '@atproto/oauth-client-node';
-import { JoseKey } from '@atproto/jwk-jose';
-import { stateStore, sessionStore, userSessions } from './oauth-stores-db';
-import { getOAuthConfig } from './oauth-config';
-import { Agent } from '@atproto/api';
-import cookie from 'cookie';
+import { Handler, HandlerEvent, HandlerResponse } from "@netlify/functions";
+import {
+  NodeOAuthClient,
+  atprotoLoopbackClientMetadata,
+} from "@atproto/oauth-client-node";
+import { JoseKey } from "@atproto/jwk-jose";
+import { stateStore, sessionStore, userSessions } from "./oauth-stores-db";
+import { getOAuthConfig } from "./oauth-config";
+import { Agent } from "@atproto/api";
+import cookie from "cookie";
 
 function normalizePrivateKey(key: string): string {
-  if (!key.includes('\n') && key.includes('\\n')) {
-    return key.replace(/\\n/g, '\n');
+  if (!key.includes("\n") && key.includes("\\n")) {
+    return key.replace(/\\n/g, "\n");
   }
   return key;
 }
 
-export const handler: Handler = async (event: HandlerEvent): Promise<HandlerResponse> => {
+export const handler: Handler = async (
+  event: HandlerEvent,
+): Promise<HandlerResponse> => {
   try {
     // Parse batch request
-    const body = JSON.parse(event.body || '{}');
+    const body = JSON.parse(event.body || "{}");
     const usernames: string[] = body.usernames || [];
-    
+
     if (!Array.isArray(usernames) || usernames.length === 0) {
       return {
         statusCode: 400,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'usernames array is required and must not be empty' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          error: "usernames array is required and must not be empty",
+        }),
       };
     }
 
···
     if (usernames.length > 50) {
       return {
         statusCode: 400,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'Maximum 50 usernames per batch' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Maximum 50 usernames per batch" }),
       };
     }
 
     // Get session from cookie
-    const cookies = event.headers.cookie ? cookie.parse(event.headers.cookie) : {};
+    const cookies = event.headers.cookie
+      ? cookie.parse(event.headers.cookie)
+      : {};
     const sessionId = cookies.atlast_session;
 
     if (!sessionId) {
       return {
         statusCode: 401,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'No session cookie' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "No session cookie" }),
       };
     }
 
···
     if (!userSession) {
       return {
         statusCode: 401,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'Invalid or expired session' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Invalid or expired session" }),
       };
     }
 
     const config = getOAuthConfig();
-    const isDev = config.clientType === 'loopback';
+    const isDev = config.clientType === "loopback";
 
     let client: NodeOAuthClient;
 
···
     } else {
       // Production with private key
       const normalizedKey = normalizePrivateKey(process.env.OAUTH_PRIVATE_KEY!);
-      const privateKey = await JoseKey.fromImportable(normalizedKey, 'main-key');
+      const privateKey = await JoseKey.fromImportable(
+        normalizedKey,
+        "main-key",
+      );
 
       client = new NodeOAuthClient({
         clientMetadata: {
           client_id: config.clientId,
-          client_name: 'ATlast',
-          client_uri: config.clientId.replace('/client-metadata.json', ''),
+          client_name: "ATlast",
+          client_uri: config.clientId.replace("/client-metadata.json", ""),
           redirect_uris: [config.redirectUri],
-          scope: 'atproto transition:generic',
-          grant_types: ['authorization_code', 'refresh_token'],
-          response_types: ['code'],
-          application_type: 'web',
-          token_endpoint_auth_method: 'private_key_jwt',
-          token_endpoint_auth_signing_alg: 'ES256',
+          scope: "atproto transition:generic",
+          grant_types: ["authorization_code", "refresh_token"],
+          response_types: ["code"],
+          application_type: "web",
+          token_endpoint_auth_method: "private_key_jwt",
+          token_endpoint_auth_signing_alg: "ES256",
           dpop_bound_access_tokens: true,
           jwks_uri: config.jwksUri,
         },
···
 
     // Restore OAuth session
     const oauthSession = await client.restore(userSession.did);
-    
+
     // Create agent from OAuth session
     const agent = new Agent(oauthSession);
 
···
           q: username,
           limit: 20,
         });
-        
+
         // Filter and rank matches (same logic as before)
         const normalize = (s: string) => s.toLowerCase().replace(/[._-]/g, "");
         const normalizedUsername = normalize(username);
 
-        const rankedActors = response.data.actors.map((actor: any) => {
-          const handlePart = actor.handle.split('.')[0];
-          const normalizedHandle = normalize(handlePart);
-          const normalizedFullHandle = normalize(actor.handle);
-          const normalizedDisplayName = normalize(actor.displayName || '');
+        const rankedActors = response.data.actors
+          .map((actor: any) => {
+            const handlePart = actor.handle.split(".")[0];
+            const normalizedHandle = normalize(handlePart);
+            const normalizedFullHandle = normalize(actor.handle);
+            const normalizedDisplayName = normalize(actor.displayName || "");
 
-          let score = 0;
-          if (normalizedHandle === normalizedUsername) score = 100;
-          else if (normalizedFullHandle === normalizedUsername) score = 90;
-          else if (normalizedDisplayName === normalizedUsername) score = 80;
-          else if (normalizedHandle.includes(normalizedUsername)) score = 60;
-          else if (normalizedFullHandle.includes(normalizedUsername)) score = 50;
-          else if (normalizedDisplayName.includes(normalizedUsername)) score = 40;
-          else if (normalizedUsername.includes(normalizedHandle)) score = 30;
+            let score = 0;
+            if (normalizedHandle === normalizedUsername) score = 100;
+            else if (normalizedFullHandle === normalizedUsername) score = 90;
+            else if (normalizedDisplayName === normalizedUsername) score = 80;
+            else if (normalizedHandle.includes(normalizedUsername)) score = 60;
+            else if (normalizedFullHandle.includes(normalizedUsername))
+              score = 50;
+            else if (normalizedDisplayName.includes(normalizedUsername))
+              score = 40;
+            else if (normalizedUsername.includes(normalizedHandle)) score = 30;
 
-          return { 
-            ...actor, 
-            matchScore: score,
-            did: actor.did
-          };
-        })
-        .filter((actor: any) => actor.matchScore > 0)
-        .sort((a: any, b: any) => b.matchScore - a.matchScore)
-        .slice(0, 5);
+            return {
+              ...actor,
+              matchScore: score,
+              did: actor.did,
+            };
+          })
+          .filter((actor: any) => actor.matchScore > 0)
+          .sort((a: any, b: any) => b.matchScore - a.matchScore)
+          .slice(0, 5);
 
         return {
           username,
           actors: rankedActors,
-          error: null
+          error: null,
         };
       } catch (error) {
         return {
           username,
           actors: [],
-          error: error instanceof Error ? error.message : 'Search failed'
+          error: error instanceof Error ? error.message : "Search failed",
         };
       }
     });
···
 
     // Enrich results with follower and post counts using getProfiles
     const allDids = results
-      .flatMap(r => r.actors.map((a: any) => a.did))
+      .flatMap((r) => r.actors.map((a: any) => a.did))
       .filter((did): did is string => !!did);
 
     if (allDids.length > 0) {
       // Create a map to store enriched profile data
-      const profileDataMap = new Map<string, { postCount: number; followerCount: number }>();
-      
+      const profileDataMap = new Map<
+        string,
+        { postCount: number; followerCount: number }
+      >();
+
       // Batch fetch profiles (25 at a time - API limit)
       const PROFILE_BATCH_SIZE = 25;
       for (let i = 0; i < allDids.length; i += PROFILE_BATCH_SIZE) {
         const batch = allDids.slice(i, i + PROFILE_BATCH_SIZE);
         try {
           const profilesResponse = await agent.app.bsky.actor.getProfiles({
-            actors: batch
+            actors: batch,
           });
-          
+
           profilesResponse.data.profiles.forEach((profile: any) => {
             profileDataMap.set(profile.did, {
               postCount: profile.postsCount || 0,
-              followerCount: profile.followersCount || 0
+              followerCount: profile.followersCount || 0,
             });
           });
         } catch (error) {
-          console.error('Failed to fetch profile batch:', error);
+          console.error("Failed to fetch profile batch:", error);
           // Continue even if one batch fails
         }
       }
-      
+
       // Merge enriched data back into results
-      results.forEach(result => {
+      results.forEach((result) => {
         result.actors = result.actors.map((actor: any) => {
           const enrichedData = profileDataMap.get(actor.did);
           return {
             ...actor,
             postCount: enrichedData?.postCount || 0,
-            followerCount: enrichedData?.followerCount || 0
+            followerCount: enrichedData?.followerCount || 0,
           };
         });
       });
···
     return {
       statusCode: 200,
       headers: {
-        'Content-Type': 'application/json',
-        'Access-Control-Allow-Origin': '*',
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
       },
       body: JSON.stringify({ results }),
     };
-
   } catch (error) {
-    console.error('Batch search error:', error);
+    console.error("Batch search error:", error);
     return {
       statusCode: 500,
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ 
-        error: 'Failed to search actors',
-        details: error instanceof Error ? error.message : 'Unknown error'
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        error: "Failed to search actors",
+        details: error instanceof Error ? error.message : "Unknown error",
       }),
     };
   }
-};
+};

netlify/functions/client-metadata.ts

···
-import { Handler, HandlerEvent, HandlerResponse } from '@netlify/functions';
+import { Handler, HandlerEvent, HandlerResponse } from "@netlify/functions";
 
-export const handler: Handler = async (event: HandlerEvent): Promise<HandlerResponse> => {
-
+export const handler: Handler = async (
+  event: HandlerEvent,
+): Promise<HandlerResponse> => {
   try {
     // Get the host that's requesting the metadata
     // This will be different for production vs preview deploys vs dev --live
-    const requestHost = process.env.DEPLOY_URL 
-    ? new URL(process.env.DEPLOY_URL).host
-    : (event.headers['x-forwarded-host'] || event.headers.host);
-    
+    const requestHost = process.env.DEPLOY_URL
+      ? new URL(process.env.DEPLOY_URL).host
+      : event.headers["x-forwarded-host"] || event.headers.host;
+
     if (!requestHost) {
       return {
         statusCode: 400,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'Missing host header' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Missing host header" }),
       };
     }
 
-     // Check if this is a loopback/development request
-    const isLoopback = requestHost.startsWith('127.0.0.1') || 
-                       requestHost.startsWith('[::1]') ||
-                       requestHost === 'localhost';
+    // Check if this is a loopback/development request
+    const isLoopback =
+      requestHost.startsWith("127.0.0.1") ||
+      requestHost.startsWith("[::1]") ||
+      requestHost === "localhost";
 
     if (isLoopback) {
       // For loopback clients, return minimal metadata
···
       // loopback clients use hardcoded metadata on the server side
       const appUrl = `http://${requestHost}`;
       const redirectUri = `${appUrl}/.netlify/functions/oauth-callback`;
-      
+
       return {
         statusCode: 200,
         headers: {
-          'Content-Type': 'application/json',
-          'Access-Control-Allow-Origin': '*',
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
         },
         body: JSON.stringify({
           client_id: appUrl, // Just the origin for loopback
-          client_name: 'ATlast (Local Dev)',
+          client_name: "ATlast (Local Dev)",
           client_uri: appUrl,
           redirect_uris: [redirectUri],
-          scope: 'atproto transition:generic',
-          grant_types: ['authorization_code', 'refresh_token'],
-          response_types: ['code'],
-          application_type: 'web',
-          token_endpoint_auth_method: 'none', // No auth for loopback
+          scope: "atproto repo:app.bsky.graph.follow",
+          grant_types: ["authorization_code", "refresh_token"],
+          response_types: ["code"],
+          application_type: "web",
+          token_endpoint_auth_method: "none", // No auth for loopback
           dpop_bound_access_tokens: true,
         }),
       };
···
 
     const metadata = {
       client_id: clientId,
-      client_name: 'ATlast',
+      client_name: "ATlast",
       client_uri: appUrl,
       redirect_uris: [redirectUri],
-      scope: 'atproto transition:generic',
-      grant_types: ['authorization_code', 'refresh_token'],
-      response_types: ['code'],
-      application_type: 'web',
-      token_endpoint_auth_method: 'private_key_jwt',
-      token_endpoint_auth_signing_alg: 'ES256',
+      scope: "atproto transition:generic",
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      application_type: "web",
+      token_endpoint_auth_method: "private_key_jwt",
+      token_endpoint_auth_signing_alg: "ES256",
       dpop_bound_access_tokens: true,
       jwks_uri: jwksUri,
     };
···
     return {
       statusCode: 200,
       headers: {
-        'Content-Type': 'application/json',
-        'Access-Control-Allow-Origin': '*',
-        'Cache-Control': 'no-store'
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Cache-Control": "no-store",
       },
       body: JSON.stringify(metadata),
     };
   } catch (error) {
-    console.error('Client metadata error:', error);
+    console.error("Client metadata error:", error);
     return {
       statusCode: 500,
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ error: 'Internal server error' }),
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ error: "Internal server error" }),
     };
   }
-};
+};

netlify/functions/db-helpers.ts

···
-import { getDbClient } from './db';
+import { getDbClient } from "./db";
 
 export async function createUpload(
   uploadId: string,
   did: string,
   sourcePlatform: string,
   totalUsers: number,
-  matchedUsers: number
+  matchedUsers: number,
 ) {
   const sql = getDbClient();
   await sql`
···
 
 export async function getOrCreateSourceAccount(
   sourcePlatform: string,
-  sourceUsername: string
+  sourceUsername: string,
 ): Promise<number> {
   const sql = getDbClient();
-  const normalized = sourceUsername.toLowerCase().replace(/[._-]/g, '');
-  
+  const normalized = sourceUsername.toLowerCase().replace(/[._-]/g, "");
+
   const result = await sql`
     INSERT INTO source_accounts (source_platform, source_username, normalized_username)
     VALUES (${sourcePlatform}, ${sourceUsername}, ${normalized})
···
       source_username = ${sourceUsername}
     RETURNING id
   `;
-  
+
   return (result as any[])[0].id;
 }
 
···
   uploadId: string,
   did: string,
   sourceAccountId: number,
-  sourceDate: string
+  sourceDate: string,
 ) {
   const sql = getDbClient();
   await sql`
···
   atprotoAvatar: string | undefined,
   matchScore: number,
   postCount: number,
-  followerCount: number
+  followerCount: number,
 ): Promise<number> {
   const sql = getDbClient();
   const result = await sql`
     INSERT INTO atproto_matches (
-      source_account_id, atproto_did, atproto_handle, 
+      source_account_id, atproto_did, atproto_handle,
       atproto_display_name, atproto_avatar, match_score,
       post_count, follower_count
     )
···
       last_verified = NOW()
     RETURNING id
   `;
-  
+
   return (result as any[])[0].id;
 }
 
 export async function markSourceAccountMatched(sourceAccountId: number) {
   const sql = getDbClient();
   await sql`
-    UPDATE source_accounts 
+    UPDATE source_accounts
     SET match_found = true, match_found_at = NOW()
     WHERE id = ${sourceAccountId}
   `;
···
   did: string,
   atprotoMatchId: number,
   sourceAccountId: number,
-  viewed: boolean = false
+  viewed: boolean = false,
 ) {
   const sql = getDbClient();
   await sql`
     INSERT INTO user_match_status (did, atproto_match_id, source_account_id, viewed, viewed_at)
-    VALUES (${did}, ${atprotoMatchId}, ${sourceAccountId}, ${viewed}, ${viewed ? 'NOW()' : null})
+    VALUES (${did}, ${atprotoMatchId}, ${sourceAccountId}, ${viewed}, ${viewed ? "NOW()" : null})
     ON CONFLICT (did, atproto_match_id) DO UPDATE SET
       viewed = ${viewed},
       viewed_at = CASE WHEN ${viewed} THEN NOW() ELSE user_match_status.viewed_at END
···
 // NEW: Bulk operations for Phase 2
 export async function bulkCreateSourceAccounts(
   sourcePlatform: string,
-  usernames: string[]
+  usernames: string[],
 ): Promise<Map<string, number>> {
   const sql = getDbClient();
-  
+
   // Prepare bulk insert values
-  const values = usernames.map(username => ({
+  const values = usernames.map((username) => ({
     platform: sourcePlatform,
     username: username,
-    normalized: username.toLowerCase().replace(/[._-]/g, '')
+    normalized: username.toLowerCase().replace(/[._-]/g, ""),
   }));
-  
+
   // Build bulk insert query with unnest
-  const platforms = values.map(v => v.platform);
-  const source_usernames = values.map(v => v.username);
-  const normalized = values.map(v => v.normalized);
+  const platforms = values.map((v) => v.platform);
+  const source_usernames = values.map((v) => v.username);
+  const normalized = values.map((v) => v.normalized);
 
   const result = await sql`
     INSERT INTO source_accounts (source_platform, source_username, normalized_username)
···
     RETURNING id, normalized_username
   `;
 
-  
   // Create map of normalized username to ID
   const idMap = new Map<string, number>();
   for (const row of result as any[]) {
     idMap.set(row.normalized_username, row.id);
   }
-  
+
   return idMap;
 }
 
 export async function bulkLinkUserToSourceAccounts(
   uploadId: string,
   did: string,
-  links: Array<{ sourceAccountId: number; sourceDate: string }>
+  links: Array<{ sourceAccountId: number; sourceDate: string }>,
 ) {
   const sql = getDbClient();
-  
+
   const numLinks = links.length;
   if (numLinks === 0) return;
 
   // Extract arrays for columns that change
-  const sourceAccountIds = links.map(l => l.sourceAccountId);
-  const sourceDates = links.map(l => l.sourceDate);
+  const sourceAccountIds = links.map((l) => l.sourceAccountId);
+  const sourceDates = links.map((l) => l.sourceDate);
 
   // Create arrays for the static columns
   const uploadIds = Array(numLinks).fill(uploadId);
   const dids = Array(numLinks).fill(did);
-  
+
   // Use the parallel UNNEST pattern, which is proven to work in other functions
   await sql`
     INSERT INTO user_source_follows (upload_id, did, source_account_id, source_date)
···
     matchScore: number;
     postCount?: number;
     followerCount?: number;
-  }>
+  }>,
 ): Promise<Map<string, number>> {
   const sql = getDbClient();
-  
+
   if (matches.length === 0) return new Map();
-  
-  const sourceAccountId = matches.map(m => m.sourceAccountId)
-  const atprotoDid = matches.map(m => m.atprotoDid)
-  const atprotoHandle = matches.map(m => m.atprotoHandle)
-  const atprotoDisplayName = matches.map(m => m.atprotoDisplayName || null)
-  const atprotoAvatar = matches.map(m => m.atprotoAvatar || null)
-  const atprotoDescription = matches.map(m => m.atprotoDescription || null)
-  const matchScore = matches.map(m => m.matchScore)
-  const postCount = matches.map(m => m.postCount || 0)
-  const followerCount = matches.map(m => m.followerCount || 0)
+
+  const sourceAccountId = matches.map((m) => m.sourceAccountId);
+  const atprotoDid = matches.map((m) => m.atprotoDid);
+  const atprotoHandle = matches.map((m) => m.atprotoHandle);
+  const atprotoDisplayName = matches.map((m) => m.atprotoDisplayName || null);
+  const atprotoAvatar = matches.map((m) => m.atprotoAvatar || null);
+  const atprotoDescription = matches.map((m) => m.atprotoDescription || null);
+  const matchScore = matches.map((m) => m.matchScore);
+  const postCount = matches.map((m) => m.postCount || 0);
+  const followerCount = matches.map((m) => m.followerCount || 0);
 
   const result = await sql`
     INSERT INTO atproto_matches (
-      source_account_id, atproto_did, atproto_handle, 
+      source_account_id, atproto_did, atproto_handle,
       atproto_display_name, atproto_avatar, atproto_description,
       match_score, post_count, follower_count
     )
···
       last_verified = NOW()
     RETURNING id, source_account_id, atproto_did
   `;
-  
+
   // Create map of "sourceAccountId:atprotoDid" to match ID
   const idMap = new Map<string, number>();
   for (const row of result as any[]) {
     idMap.set(`${row.source_account_id}:${row.atproto_did}`, row.id);
   }
-  
+
   return idMap;
 }
 
-export async function bulkMarkSourceAccountsMatched(sourceAccountIds: number[]) {
+export async function bulkMarkSourceAccountsMatched(
+  sourceAccountIds: number[],
+) {
   const sql = getDbClient();
-  
+
   if (sourceAccountIds.length === 0) return;
-  
+
   await sql`
-    UPDATE source_accounts 
+    UPDATE source_accounts
     SET match_found = true, match_found_at = NOW()
     WHERE id = ANY(${sourceAccountIds})
   `;
···
     atprotoMatchId: number;
     sourceAccountId: number;
     viewed: boolean;
-  }>
+  }>,
 ) {
   const sql = getDbClient();
-  
+
   if (statuses.length === 0) return;
-  
-  const did = statuses.map(s => s.did)
-  const atprotoMatchId = statuses.map(s => s.atprotoMatchId)
-  const sourceAccountId = statuses.map(s => s.sourceAccountId)
-  const viewedFlags = statuses.map(s => s.viewed);
-  const viewedDates = statuses.map(s => s.viewed ? new Date() : null);
+
+  const did = statuses.map((s) => s.did);
+  const atprotoMatchId = statuses.map((s) => s.atprotoMatchId);
+  const sourceAccountId = statuses.map((s) => s.sourceAccountId);
+  const viewedFlags = statuses.map((s) => s.viewed);
+  const viewedDates = statuses.map((s) => (s.viewed ? new Date() : null));
 
   await sql`
     INSERT INTO user_match_status (did, atproto_match_id, source_account_id, viewed, viewed_at)
···
       viewed = EXCLUDED.viewed,
       viewed_at = CASE WHEN EXCLUDED.viewed THEN NOW() ELSE user_match_status.viewed_at END
   `;
-}
+}

netlify/functions/db.ts

···
-import { neon, NeonQueryFunction } from '@neondatabase/serverless';
+import { neon, NeonQueryFunction } from "@neondatabase/serverless";
 
 let sql: NeonQueryFunction<any, any> | undefined = undefined;
 let connectionInitialized = false;
···
 export async function initDB() {
   const sql = getDbClient();
 
-  console.log('🧠 Connecting to DB:', process.env.NETLIFY_DATABASE_URL);
+  console.log("🧠 Connecting to DB:", process.env.NETLIFY_DATABASE_URL);
 
   try {
-    const res: any = await sql`SELECT current_database() AS db, current_user AS user, NOW() AS now`;
-    console.log('✅ Connected:', res[0]);
+    const res: any =
+      await sql`SELECT current_database() AS db, current_user AS user, NOW() AS now`;
+    console.log("✅ Connected:", res[0]);
   } catch (e) {
-    console.error('❌ Connection failed:', e);
+    console.error("❌ Connection failed:", e);
     throw e;
   }
 
···
   `;
 
   // ==================== ENHANCED INDEXES FOR PHASE 2 ====================
-  
+
   // Existing indexes
   await sql`CREATE INDEX IF NOT EXISTS idx_source_accounts_to_check ON source_accounts(source_platform, match_found, last_checked)`;
   await sql`CREATE INDEX IF NOT EXISTS idx_source_accounts_platform ON source_accounts(source_platform)`;
···
 
   // For sorting
   await sql`CREATE INDEX IF NOT EXISTS idx_atproto_matches_stats ON atproto_matches(source_account_id, found_at DESC, post_count DESC, follower_count DESC)`;
-  
+
   // For session lookups (most frequent query)
-await sql`CREATE INDEX IF NOT EXISTS idx_user_sessions_did ON user_sessions(did)`;
-await sql`CREATE INDEX IF NOT EXISTS idx_user_sessions_expires ON user_sessions(expires_at)`;
-  
+  await sql`CREATE INDEX IF NOT EXISTS idx_user_sessions_did ON user_sessions(did)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_user_sessions_expires ON user_sessions(expires_at)`;
+
   // For OAuth state/session cleanup
   await sql`CREATE INDEX IF NOT EXISTS idx_oauth_states_expires ON oauth_states(expires_at)`;
   await sql`CREATE INDEX IF NOT EXISTS idx_oauth_sessions_expires ON oauth_sessions(expires_at)`;
-  
+
   // For upload queries by user
   await sql`CREATE INDEX IF NOT EXISTS idx_user_uploads_did_created ON user_uploads(did, created_at DESC)`;
-  
+
   // For upload details pagination (composite index for ORDER BY + JOIN)
   await sql`CREATE INDEX IF NOT EXISTS idx_user_source_follows_upload_created ON user_source_follows(upload_id, source_account_id)`;
-  
+
   // For match status queries
   await sql`CREATE INDEX IF NOT EXISTS idx_user_match_status_match_id ON user_match_status(atproto_match_id)`;
-  
+
   // Composite index for the common join pattern in get-upload-details
   await sql`CREATE INDEX IF NOT EXISTS idx_atproto_matches_source_active ON atproto_matches(source_account_id, is_active) WHERE is_active = true`;
-  
+
   // For bulk operations - normalized username lookups
   await sql`CREATE INDEX IF NOT EXISTS idx_source_accounts_normalized ON source_accounts(normalized_username, source_platform)`;
 
-  console.log('✅ Database indexes created/verified');
+  console.log("✅ Database indexes created/verified");
 }
 
 export async function cleanupExpiredSessions() {
   const sql = getDbClient();
-  
+
   // Use indexes for efficient cleanup
-  const statesDeleted = await sql`DELETE FROM oauth_states WHERE expires_at < NOW()`;
-  const sessionsDeleted = await sql`DELETE FROM oauth_sessions WHERE expires_at < NOW()`;
-  const userSessionsDeleted = await sql`DELETE FROM user_sessions WHERE expires_at < NOW()`;
-  
-  console.log('🧹 Cleanup:', {
+  const statesDeleted =
+    await sql`DELETE FROM oauth_states WHERE expires_at < NOW()`;
+  const sessionsDeleted =
+    await sql`DELETE FROM oauth_sessions WHERE expires_at < NOW()`;
+  const userSessionsDeleted =
+    await sql`DELETE FROM user_sessions WHERE expires_at < NOW()`;
+
+  console.log("🧹 Cleanup:", {
     states: (statesDeleted as any).length,
     sessions: (sessionsDeleted as any).length,
-    userSessions: (userSessionsDeleted as any).length
+    userSessions: (userSessionsDeleted as any).length,
   });
 }
 
-export { getDbClient as sql };
+export { getDbClient as sql };

netlify/functions/get-upload-details.ts

···
-import { Handler, HandlerEvent, HandlerResponse } from '@netlify/functions';
-import { userSessions } from './oauth-stores-db';
-import { getDbClient } from './db';
-import cookie from 'cookie';
+import { Handler, HandlerEvent, HandlerResponse } from "@netlify/functions";
+import { userSessions } from "./oauth-stores-db";
+import { getDbClient } from "./db";
+import cookie from "cookie";
 
 const DEFAULT_PAGE_SIZE = 50;
 const MAX_PAGE_SIZE = 100;
 
-export const handler: Handler = async (event: HandlerEvent): Promise<HandlerResponse> => {
+export const handler: Handler = async (
+  event: HandlerEvent,
+): Promise<HandlerResponse> => {
   try {
     const uploadId = event.queryStringParameters?.uploadId;
-    const page = parseInt(event.queryStringParameters?.page || '1');
+    const page = parseInt(event.queryStringParameters?.page || "1");
     const pageSize = Math.min(
-      parseInt(event.queryStringParameters?.pageSize || String(DEFAULT_PAGE_SIZE)),
-      MAX_PAGE_SIZE
+      parseInt(
+        event.queryStringParameters?.pageSize || String(DEFAULT_PAGE_SIZE),
+      ),
+      MAX_PAGE_SIZE,
     );
 
     if (!uploadId) {
       return {
         statusCode: 400,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'uploadId is required' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "uploadId is required" }),
       };
     }
 
     if (page < 1 || pageSize < 1) {
       return {
         statusCode: 400,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'Invalid page or pageSize parameters' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Invalid page or pageSize parameters" }),
       };
     }
 
     // Get session from cookie
-    const cookies = event.headers.cookie ? cookie.parse(event.headers.cookie) : {};
+    const cookies = event.headers.cookie
+      ? cookie.parse(event.headers.cookie)
+      : {};
     const sessionId = cookies.atlast_session;
 
     if (!sessionId) {
       return {
         statusCode: 401,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'No session cookie' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "No session cookie" }),
       };
     }
 
···
     if (!userSession) {
       return {
         statusCode: 401,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'Invalid or expired session' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Invalid or expired session" }),
       };
     }
 
···
     if ((uploadCheck as any[]).length === 0) {
       return {
         statusCode: 404,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'Upload not found' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Upload not found" }),
       };
     }
 
···
 
     // Fetch paginated results with optimized query
     const results = await sql`
-      SELECT 
+      SELECT
         sa.source_username,
         sa.normalized_username,
         usf.source_date,
···
       LEFT JOIN atproto_matches am ON sa.id = am.source_account_id AND am.is_active = true
       LEFT JOIN user_match_status ums ON am.id = ums.atproto_match_id AND ums.did = ${userSession.did}
       WHERE usf.upload_id = ${uploadId}
-      ORDER BY 
+      ORDER BY
         -- 1. Users with matches first
         CASE WHEN am.atproto_did IS NOT NULL THEN 0 ELSE 1 END,
         -- 2. New matches (found after initial upload)
···
 
     // Group results by source username
     const groupedResults = new Map<string, any>();
-    
+
     (results as any[]).forEach((row: any) => {
       const username = row.source_username;
-      
+
       // Get or create the entry for this username
       let userResult = groupedResults.get(username);
-      
+
       if (!userResult) {
         userResult = {
           sourceUser: {
             username: username,
-            date: row.source_date || '',
+            date: row.source_date || "",
           },
           atprotoMatches: [],
         };
         groupedResults.set(username, userResult); // Add to map, this preserves the order
       }
-      
+
       // Add the match (if it exists) to the array
       if (row.atproto_did) {
         userResult.atprotoMatches.push({
···
     return {
       statusCode: 200,
       headers: {
-        'Content-Type': 'application/json',
-        'Access-Control-Allow-Origin': '*',
-        'Cache-Control': 'private, max-age=600', // 10 minute browser cache
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Cache-Control": "private, max-age=600", // 10 minute browser cache
       },
-      body: JSON.stringify({ 
+      body: JSON.stringify({
         results: searchResults,
         pagination: {
           page,
···
           totalPages,
           totalUsers,
           hasNextPage: page < totalPages,
-          hasPrevPage: page > 1
-        }
+          hasPrevPage: page > 1,
+        },
       }),
     };
-
   } catch (error) {
-    console.error('Get upload details error:', error);
+    console.error("Get upload details error:", error);
     return {
       statusCode: 500,
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ 
-        error: 'Failed to fetch upload details',
-        details: error instanceof Error ? error.message : 'Unknown error'
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        error: "Failed to fetch upload details",
+        details: error instanceof Error ? error.message : "Unknown error",
       }),
     };
   }
-};
+};

netlify/functions/get-uploads.ts

···
-import { Handler, HandlerEvent, HandlerResponse } from '@netlify/functions';
-import { userSessions } from './oauth-stores-db';
-import { getDbClient } from './db';
-import cookie from 'cookie';
+import { Handler, HandlerEvent, HandlerResponse } from "@netlify/functions";
+import { userSessions } from "./oauth-stores-db";
+import { getDbClient } from "./db";
+import cookie from "cookie";
 
-export const handler: Handler = async (event: HandlerEvent): Promise<HandlerResponse> => {
+export const handler: Handler = async (
+  event: HandlerEvent,
+): Promise<HandlerResponse> => {
   try {
     // Get session from cookie
-    const cookies = event.headers.cookie ? cookie.parse(event.headers.cookie) : {};
+    const cookies = event.headers.cookie
+      ? cookie.parse(event.headers.cookie)
+      : {};
     const sessionId = cookies.atlast_session;
 
     if (!sessionId) {
       return {
         statusCode: 401,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'No session cookie' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "No session cookie" }),
       };
     }
 
···
     if (!userSession) {
       return {
         statusCode: 401,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'Invalid or expired session' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Invalid or expired session" }),
       };
     }
 
···
 
     // Fetch all uploads for this user
     const uploads = await sql`
-      SELECT 
+      SELECT
         upload_id,
         source_platform,
         created_at,
···
     return {
       statusCode: 200,
       headers: {
-        'Content-Type': 'application/json',
-        'Access-Control-Allow-Origin': '*',
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
       },
       body: JSON.stringify({
         uploads: (uploads as any[]).map((upload: any) => ({
···
           totalUsers: upload.total_users,
           matchedUsers: upload.matched_users,
           unmatchedUsers: upload.unmatched_users,
-        }))
+        })),
       }),
     };
-
   } catch (error) {
-    console.error('Get uploads error:', error);
+    console.error("Get uploads error:", error);
     return {
       statusCode: 500,
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ 
-        error: 'Failed to fetch uploads',
-        details: error instanceof Error ? error.message : 'Unknown error'
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        error: "Failed to fetch uploads",
+        details: error instanceof Error ? error.message : "Unknown error",
       }),
     };
   }
-};
+};

netlify/functions/init-db.ts

···
-import { Handler } from '@netlify/functions';
-import { initDB } from './db';
+import { Handler } from "@netlify/functions";
+import { initDB } from "./db";
 
 export const handler: Handler = async () => {
   try {
     await initDB();
     return {
       statusCode: 200,
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ message: 'Database initialized successfully' }),
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ message: "Database initialized successfully" }),
     };
   } catch (error) {
-    console.error('Database initialization error:', error);
+    console.error("Database initialization error:", error);
     return {
       statusCode: 500,
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ 
-        error: 'Failed to initialize database',
-        details: error instanceof Error ? error.message : 'Unknown error',
-        stack: error instanceof Error ? error.stack : undefined
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        error: "Failed to initialize database",
+        details: error instanceof Error ? error.message : "Unknown error",
+        stack: error instanceof Error ? error.stack : undefined,
       }),
     };
   }
-};
+};

netlify/functions/jwks.ts

···
-import { Handler } from '@netlify/functions';
+import { Handler } from "@netlify/functions";
 
 const PUBLIC_JWK = {
-  "kty": "EC",
-  "x": "3sVbr4xwN7UtmG1L19vL0x9iN-FRcl7p-Wja_xPbhhk",       
-  "y": "Y1XKDaAyDwijp8aEIGHmO46huKjajSQH2cbfpWaWpQ4",       
-  "crv": "P-256",
-  "kid": "main-key",
-  "use": "sig",
-  "alg": "ES256"
+  kty: "EC",
+  x: "3sVbr4xwN7UtmG1L19vL0x9iN-FRcl7p-Wja_xPbhhk",
+  y: "Y1XKDaAyDwijp8aEIGHmO46huKjajSQH2cbfpWaWpQ4",
+  crv: "P-256",
+  kid: "main-key",
+  use: "sig",
+  alg: "ES256",
 };
 export const handler: Handler = async () => {
   return {
     statusCode: 200,
     headers: {
-      'Content-Type': 'application/json',
-      'Access-Control-Allow-Origin': '*',
-      'Cache-Control': 'public, max-age=3600'
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*",
+      "Cache-Control": "public, max-age=3600",
     },
-    body: JSON.stringify({ keys: [PUBLIC_JWK] })
+    body: JSON.stringify({ keys: [PUBLIC_JWK] }),
   };
-};
+};

netlify/functions/oauth-callback.ts

···
-import { Handler, HandlerEvent, HandlerResponse } from '@netlify/functions';
-import { NodeOAuthClient, atprotoLoopbackClientMetadata } from '@atproto/oauth-client-node';
-import { JoseKey } from '@atproto/jwk-jose';
-import { stateStore, sessionStore, userSessions } from './oauth-stores-db';
-import { getOAuthConfig } from './oauth-config';
-import * as crypto from 'crypto';
+import { Handler, HandlerEvent, HandlerResponse } from "@netlify/functions";
+import {
+  NodeOAuthClient,
+  atprotoLoopbackClientMetadata,
+} from "@atproto/oauth-client-node";
+import { JoseKey } from "@atproto/jwk-jose";
+import { stateStore, sessionStore, userSessions } from "./oauth-stores-db";
+import { getOAuthConfig } from "./oauth-config";
+import * as crypto from "crypto";
 
 function normalizePrivateKey(key: string): string {
-  if (!key.includes('\n') && key.includes('\\n')) {
-    return key.replace(/\\n/g, '\n');
+  if (!key.includes("\n") && key.includes("\\n")) {
+    return key.replace(/\\n/g, "\n");
   }
   return key;
 }
 
-export const handler: Handler = async (event: HandlerEvent): Promise<HandlerResponse> => {
+export const handler: Handler = async (
+  event: HandlerEvent,
+): Promise<HandlerResponse> => {
   const config = getOAuthConfig();
-  const isDev = config.clientType === 'loopback';
-  
-  let currentUrl = isDev 
-    ? 'http://127.0.0.1:8888'
-    : (process.env.DEPLOY_URL 
-        ? `https://${new URL(process.env.DEPLOY_URL).host}`
-        : process.env.URL || process.env.DEPLOY_PRIME_URL || 'https://atlast.byarielm.fyi');
+  const isDev = config.clientType === "loopback";
+
+  let currentUrl = isDev
+    ? "http://127.0.0.1:8888"
+    : process.env.DEPLOY_URL
+      ? `https://${new URL(process.env.DEPLOY_URL).host}`
+      : process.env.URL ||
+        process.env.DEPLOY_PRIME_URL ||
+        "https://atlast.byarielm.fyi";
 
   try {
-    const params = new URLSearchParams(event.rawUrl.split('?')[1] || '');
-    const code = params.get('code');
-    const state = params.get('state');
+    const params = new URLSearchParams(event.rawUrl.split("?")[1] || "");
+    const code = params.get("code");
+    const state = params.get("state");
 
-    console.log('OAuth callback - Mode:', isDev ? 'loopback' : 'production');
-    console.log('OAuth callback - URL:', currentUrl);
+    console.log("OAuth callback - Mode:", isDev ? "loopback" : "production");
+    console.log("OAuth callback - URL:", currentUrl);
 
     if (!code || !state) {
       return {
         statusCode: 302,
         headers: {
-          'Location': `${currentUrl}/?error=Missing OAuth parameters`
+          Location: `${currentUrl}/?error=Missing OAuth parameters`,
         },
-        body: ''
+        body: "",
       };
     }
 
···
 
     if (isDev) {
       // LOOPBACK MODE: Use atprotoLoopbackClientMetadata and NO keyset
-      console.log('🔧 Loopback callback');
-      
+      console.log("🔧 Loopback callback");
+
       const clientMetadata = atprotoLoopbackClientMetadata(config.clientId);
-      
+
       client = new NodeOAuthClient({
         clientMetadata: clientMetadata,
         // No keyset for loopback!
···
     } else {
       // PRODUCTION MODE
       if (!process.env.OAUTH_PRIVATE_KEY) {
-        console.error('OAUTH_PRIVATE_KEY not set');
+        console.error("OAUTH_PRIVATE_KEY not set");
         return {
           statusCode: 302,
-          headers: { 'Location': `${currentUrl}/?error=Server configuration error` },
-          body: ''
+          headers: {
+            Location: `${currentUrl}/?error=Server configuration error`,
+          },
+          body: "",
         };
       }
 
       const normalizedKey = normalizePrivateKey(process.env.OAUTH_PRIVATE_KEY);
-      const privateKey = await JoseKey.fromImportable(normalizedKey, 'main-key');
-      
-      const currentHost = process.env.DEPLOY_URL 
+      const privateKey = await JoseKey.fromImportable(
+        normalizedKey,
+        "main-key",
+      );
+
+      const currentHost = process.env.DEPLOY_URL
         ? new URL(process.env.DEPLOY_URL).host
-        : (event.headers['x-forwarded-host'] || event.headers.host);
-      
+        : event.headers["x-forwarded-host"] || event.headers.host;
+
       currentUrl = `https://${currentHost}`;
       const redirectUri = `${currentUrl}/.netlify/functions/oauth-callback`;
       const jwksUri = `${currentUrl}/.netlify/functions/jwks`;
···
       client = new NodeOAuthClient({
         clientMetadata: {
           client_id: clientId,
-          client_name: 'ATlast',
+          client_name: "ATlast",
           client_uri: currentUrl,
           redirect_uris: [redirectUri],
-          scope: 'atproto transition:generic',
-          grant_types: ['authorization_code', 'refresh_token'],
-          response_types: ['code'],
-          application_type: 'web',
-          token_endpoint_auth_method: 'private_key_jwt',
-          token_endpoint_auth_signing_alg: 'ES256',
+          scope: "atproto transition:generic",
+          grant_types: ["authorization_code", "refresh_token"],
+          response_types: ["code"],
+          application_type: "web",
+          token_endpoint_auth_method: "private_key_jwt",
+          token_endpoint_auth_signing_alg: "ES256",
           dpop_bound_access_tokens: true,
           jwks_uri: jwksUri,
         } as any,
···
 
     // Cookie flags - no Secure flag for loopback
     const cookieFlags = isDev
-      ? 'HttpOnly; SameSite=Lax; Max-Age=1209600; Path=/'
-      : 'HttpOnly; SameSite=Lax; Max-Age=1209600; Path=/; Secure';
-    
+      ? "HttpOnly; SameSite=Lax; Max-Age=1209600; Path=/"
+      : "HttpOnly; SameSite=Lax; Max-Age=1209600; Path=/; Secure";
+
     return {
       statusCode: 302,
       headers: {
-        'Location': `${currentUrl}/?session=${sessionId}`,
-        'Set-Cookie': `atlast_session=${sessionId}; ${cookieFlags}`
+        Location: `${currentUrl}/?session=${sessionId}`,
+        "Set-Cookie": `atlast_session=${sessionId}; ${cookieFlags}`,
       },
-      body: ''
+      body: "",
     };
-
   } catch (error) {
-    console.error('OAuth callback error:', error);
+    console.error("OAuth callback error:", error);
     return {
       statusCode: 302,
       headers: {
-        'Location': `${currentUrl}/?error=OAuth failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+        Location: `${currentUrl}/?error=OAuth failed: ${error instanceof Error ? error.message : "Unknown error"}`,
       },
-      body: ''
+      body: "",
     };
   }
-};
+};

netlify/functions/oauth-config.ts

···
 export function getOAuthConfig() {
   // Check if we have a public URL (production or --live mode)
-  const baseUrl = process.env.URL || process.env.DEPLOY_URL || process.env.DEPLOY_PRIME_URL;
+  const baseUrl =
+    process.env.URL || process.env.DEPLOY_URL || process.env.DEPLOY_PRIME_URL;
 
   // Development: loopback client for local dev
   // Check if we're running on localhost (true local dev)
-  const isLocalhost = !baseUrl || 
-                      baseUrl.includes('localhost') || 
-                      baseUrl.includes('127.0.0.1') ||
-                      baseUrl.startsWith('http://localhost') ||
-                      baseUrl.startsWith('http://127.0.0.1');
-  
+  const isLocalhost =
+    !baseUrl ||
+    baseUrl.includes("localhost") ||
+    baseUrl.includes("127.0.0.1") ||
+    baseUrl.startsWith("http://localhost") ||
+    baseUrl.startsWith("http://127.0.0.1");
+
   // Use loopback for localhost, production for everything else
   const isDev = isLocalhost;
 
   if (isDev) {
-    const port = process.env.PORT || '8888';
+    const port = process.env.PORT || "8888";
 
     // Special loopback client_id format with query params
     const clientId = `http://localhost?${new URLSearchParams([
-      ['redirect_uri', `http://127.0.0.1:${port}/.netlify/functions/oauth-callback`],
-      ['scope', 'atproto transition:generic'],
+      [
+        "redirect_uri",
+        `http://127.0.0.1:${port}/.netlify/functions/oauth-callback`,
+      ],
+      ["scope", "atproto transition:generic"],
     ])}`;
 
-    console.log('Using loopback OAuth for local development');
-    console.log('Access your app at: http://127.0.0.1:' + port);
-    
+    console.log("Using loopback OAuth for local development");
+    console.log("Access your app at: http://127.0.0.1:" + port);
+
     return {
       clientId: clientId,
       redirectUri: `http://127.0.0.1:${port}/.netlify/functions/oauth-callback`,
       jwksUri: undefined,
-      clientType: 'loopback' as const,
+      clientType: "loopback" as const,
     };
   }
 
   // Production: discoverable client logic
   if (!baseUrl) {
-      throw new Error('No public URL available');
+    throw new Error("No public URL available");
   }
-  
-  console.log('Using confidential OAuth client for production');
-  console.log('OAuth Config URLs:', {
+
+  console.log("Using confidential OAuth client for production");
+  console.log("OAuth Config URLs:", {
     DEPLOY_PRIME_URL: process.env.DEPLOY_PRIME_URL,
     URL: process.env.URL,
     CONTEXT: process.env.CONTEXT,
-    using: baseUrl
+    using: baseUrl,
   });
 
   return {
     clientId: `${baseUrl}/.netlify/functions/client-metadata`, // discoverable client URL
     redirectUri: `${baseUrl}/.netlify/functions/oauth-callback`,
     jwksUri: `${baseUrl}/.netlify/functions/jwks`,
-    clientType: 'discoverable' as const,
+    clientType: "discoverable" as const,
     usePrivateKey: true,
   };
-}
+}

netlify/functions/oauth-start.ts

···
-import { Handler, HandlerEvent, HandlerResponse } from '@netlify/functions';
-import { NodeOAuthClient, atprotoLoopbackClientMetadata } from '@atproto/oauth-client-node';
-import { JoseKey } from '@atproto/jwk-jose';
-import { stateStore, sessionStore } from './oauth-stores-db';
-import { getOAuthConfig } from './oauth-config';
+import { Handler, HandlerEvent, HandlerResponse } from "@netlify/functions";
+import {
+  NodeOAuthClient,
+  atprotoLoopbackClientMetadata,
+} from "@atproto/oauth-client-node";
+import { JoseKey } from "@atproto/jwk-jose";
+import { stateStore, sessionStore } from "./oauth-stores-db";
+import { getOAuthConfig } from "./oauth-config";
 
 interface OAuthStartRequestBody {
   login_hint?: string;
···
 }
 
 function normalizePrivateKey(key: string): string {
-  if (!key.includes('\n') && key.includes('\\n')) {
-    return key.replace(/\\n/g, '\n');
+  if (!key.includes("\n") && key.includes("\\n")) {
+    return key.replace(/\\n/g, "\n");
   }
   return key;
 }
 
-export const handler: Handler = async (event: HandlerEvent): Promise<HandlerResponse> => {
+export const handler: Handler = async (
+  event: HandlerEvent,
+): Promise<HandlerResponse> => {
   try {
     let loginHint: string | undefined = undefined;
-    
+
     if (event.body) {
       const parsed: OAuthStartRequestBody = JSON.parse(event.body);
       loginHint = parsed.login_hint;
···
     if (!loginHint) {
       return {
         statusCode: 400,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'login_hint (handle or DID) is required' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          error: "login_hint (handle or DID) is required",
+        }),
       };
     }
 
     const config = getOAuthConfig();
-    const isDev = config.clientType === 'loopback';
+    const isDev = config.clientType === "loopback";
 
     let client: NodeOAuthClient;
 
     if (isDev) {
       // LOOPBACK MODE: Use atprotoLoopbackClientMetadata and NO keyset
-      console.log('🔧 Using loopback OAuth client for development');
-      console.log('Client ID:', config.clientId);
-      
+      console.log("🔧 Using loopback OAuth client for development");
+      console.log("Client ID:", config.clientId);
+
       const clientMetadata = atprotoLoopbackClientMetadata(config.clientId);
-      
+
       client = new NodeOAuthClient({
         clientMetadata: clientMetadata,
         stateStore: stateStore as any,
···
       });
     } else {
       // PRODUCTION MODE: Full confidential client with keyset
-      console.log('🔐 Using confidential OAuth client for production');
-      
+      console.log("🔐 Using confidential OAuth client for production");
+
       if (!process.env.OAUTH_PRIVATE_KEY) {
-        throw new Error('OAUTH_PRIVATE_KEY required for production');
+        throw new Error("OAUTH_PRIVATE_KEY required for production");
       }
 
       const normalizedKey = normalizePrivateKey(process.env.OAUTH_PRIVATE_KEY);
-      const privateKey = await JoseKey.fromImportable(normalizedKey, 'main-key');
+      const privateKey = await JoseKey.fromImportable(
+        normalizedKey,
+        "main-key",
+      );
 
-      const currentHost = process.env.DEPLOY_URL 
+      const currentHost = process.env.DEPLOY_URL
         ? new URL(process.env.DEPLOY_URL).host
-        : (event.headers['x-forwarded-host'] || event.headers.host);
+        : event.headers["x-forwarded-host"] || event.headers.host;
 
       if (!currentHost) {
-        throw new Error('Missing host header');
+        throw new Error("Missing host header");
       }
 
       const currentUrl = `https://${currentHost}`;
···
       client = new NodeOAuthClient({
         clientMetadata: {
           client_id: clientId,
-          client_name: 'ATlast',
+          client_name: "ATlast",
           client_uri: currentUrl,
           redirect_uris: [redirectUri],
-          scope: 'atproto transition:generic',
-          grant_types: ['authorization_code', 'refresh_token'],
-          response_types: ['code'],
-          application_type: 'web',
-          token_endpoint_auth_method: 'private_key_jwt',
-          token_endpoint_auth_signing_alg: 'ES256',
+          scope: "atproto transition:generic",
+          grant_types: ["authorization_code", "refresh_token"],
+          response_types: ["code"],
+          application_type: "web",
+          token_endpoint_auth_method: "private_key_jwt",
+          token_endpoint_auth_signing_alg: "ES256",
           dpop_bound_access_tokens: true,
           jwks_uri: jwksUri,
         } as any,
···
     }
 
     const authUrl = await client.authorize(loginHint, {
-      scope: 'atproto transition:generic',
+      scope: "atproto transition:generic",
     });
 
     return {
       statusCode: 200,
-      headers: { 'Content-Type': 'application/json' },
+      headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ url: authUrl.toString() }),
     };
   } catch (error) {
-    console.error('OAuth start error:', error);
+    console.error("OAuth start error:", error);
 
     // Provide user-friendly error messages
-    let userMessage = 'Failed to start authentication';
-    
+    let userMessage = "Failed to start authentication";
+
     if (error instanceof Error) {
-      if (error.message.includes('resolve') || error.message.includes('not found')) {
-        userMessage = 'Account not found. Please check your handle and try again.';
-      } else if (error.message.includes('network') || error.message.includes('timeout')) {
-        userMessage = 'Network error. Please check your connection and try again.';
-      } else if (error.message.includes('Invalid identifier')) {
-        userMessage = 'Invalid handle format. Please use the format: username.bsky.social';
+      if (
+        error.message.includes("resolve") ||
+        error.message.includes("not found")
+      ) {
+        userMessage =
+          "Account not found. Please check your handle and try again.";
+      } else if (
+        error.message.includes("network") ||
+        error.message.includes("timeout")
+      ) {
+        userMessage =
+          "Network error. Please check your connection and try again.";
+      } else if (error.message.includes("Invalid identifier")) {
+        userMessage =
+          "Invalid handle format. Please use the format: username.bsky.social";
       }
     }
-    
+
     return {
       statusCode: 500,
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ 
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
         error: userMessage,
-        details: error instanceof Error ? error.message : 'Unknown error',
+        details: error instanceof Error ? error.message : "Unknown error",
       }),
     };
   }
-};
+};

netlify/functions/oauth-stores-db.ts

···
-import { getDbClient } from './db';
+import { getDbClient } from "./db";
 
 interface StateData {
   dpopKey: any;
···
 export class PostgresStateStore {
   async get(key: string): Promise<StateData | undefined> {
     const result = await sql`
-      SELECT data FROM oauth_states 
+      SELECT data FROM oauth_states
       WHERE key = ${key} AND expires_at > NOW()
     `;
     return (result as Record<string, any>[])[0]?.data as StateData | undefined;
···
 export class PostgresSessionStore {
   async get(key: string): Promise<SessionData | undefined> {
     const result = await sql`
-      SELECT data FROM oauth_sessions 
+      SELECT data FROM oauth_sessions
       WHERE key = ${key} AND expires_at > NOW()
     `;
-    return (result as Record<string, any>[])[0]?.data as SessionData | undefined;
+    return (result as Record<string, any>[])[0]?.data as
+      | SessionData
+      | undefined;
   }
 
   async set(key: string, value: SessionData): Promise<void> {
···
 export class PostgresUserSessionStore {
   async get(sessionId: string): Promise<{ did: string } | undefined> {
     const result = await sql`
-      SELECT did FROM user_sessions 
+      SELECT did FROM user_sessions
       WHERE session_id = ${sessionId} AND expires_at > NOW()
     `;
     const row = (result as Record<string, any>[])[0];
···
 
 export const stateStore = new PostgresStateStore();
 export const sessionStore = new PostgresSessionStore();
-export const userSessions = new PostgresUserSessionStore();
+export const userSessions = new PostgresUserSessionStore();

netlify/functions/save-results.ts

···
-import { Handler, HandlerEvent, HandlerResponse } from '@netlify/functions';
-import { userSessions } from './oauth-stores-db';
-import cookie from 'cookie';
+import { Handler, HandlerEvent, HandlerResponse } from "@netlify/functions";
+import { userSessions } from "./oauth-stores-db";
+import cookie from "cookie";
 import {
   createUpload,
   bulkCreateSourceAccounts,
   bulkLinkUserToSourceAccounts,
   bulkStoreAtprotoMatches,
   bulkMarkSourceAccountsMatched,
-  bulkCreateUserMatchStatus
-} from './db-helpers';
-import { getDbClient } from './db';
+  bulkCreateUserMatchStatus,
+} from "./db-helpers";
+import { getDbClient } from "./db";
 
 interface SearchResult {
   sourceUser: {
···
   results: SearchResult[];
 }
 
-export const handler: Handler = async (event: HandlerEvent): Promise<HandlerResponse> => {
-  
-  if (event.httpMethod !== 'POST') {
+export const handler: Handler = async (
+  event: HandlerEvent,
+): Promise<HandlerResponse> => {
+  if (event.httpMethod !== "POST") {
     return {
       statusCode: 405,
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ error: 'Method not allowed' }),
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ error: "Method not allowed" }),
     };
   }
 
   try {
     // Get session from cookie
-    const cookies = event.headers.cookie ? cookie.parse(event.headers.cookie) : {};
+    const cookies = event.headers.cookie
+      ? cookie.parse(event.headers.cookie)
+      : {};
     const sessionId = cookies.atlast_session;
 
     if (!sessionId) {
       return {
         statusCode: 401,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'No session cookie' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "No session cookie" }),
       };
     }
 
···
     if (!userSession) {
       return {
         statusCode: 401,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'Invalid or expired session' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Invalid or expired session" }),
       };
     }
 
     // Parse request body
-    const body: SaveResultsRequest = JSON.parse(event.body || '{}');
+    const body: SaveResultsRequest = JSON.parse(event.body || "{}");
     const { uploadId, sourcePlatform, results } = body;
 
     if (!uploadId || !sourcePlatform || !Array.isArray(results)) {
       return {
         statusCode: 400,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'uploadId, sourcePlatform, and results are required' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          error: "uploadId, sourcePlatform, and results are required",
+        }),
       };
     }
 
···
 
     // Check for recent uploads from this user
     const recentUpload = await sql`
-      SELECT upload_id FROM user_uploads 
-      WHERE did = ${userSession.did} 
+      SELECT upload_id FROM user_uploads
+      WHERE did = ${userSession.did}
       AND created_at > NOW() - INTERVAL '5 seconds'
       ORDER BY created_at DESC
       LIMIT 1
     `;
 
     if ((recentUpload as any[]).length > 0) {
-      console.log(`User ${userSession.did} already saved within 5 seconds, skipping duplicate`);
+      console.log(
+        `User ${userSession.did} already saved within 5 seconds, skipping duplicate`,
+      );
       return {
         statusCode: 200,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ success: true, message: 'Recently saved' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ success: true, message: "Recently saved" }),
       };
     }
 
···
       userSession.did,
       sourcePlatform,
       results.length,
-      0
+      0,
     );
 
     // BULK OPERATION 1: Create all source accounts at once
-    const allUsernames = results.map(r => r.sourceUser.username);
-    const sourceAccountIdMap = await bulkCreateSourceAccounts(sourcePlatform, allUsernames);
-    
+    const allUsernames = results.map((r) => r.sourceUser.username);
+    const sourceAccountIdMap = await bulkCreateSourceAccounts(
+      sourcePlatform,
+      allUsernames,
+    );
+
     // BULK OPERATION 2: Link all users to source accounts
-    const links = results.map(result => {
-      const normalized = result.sourceUser.username.toLowerCase().replace(/[._-]/g, '');
-      const sourceAccountId = sourceAccountIdMap.get(normalized);
-      return {
-        sourceAccountId: sourceAccountId!,
-        sourceDate: result.sourceUser.date
-      };
-    }).filter(link => link.sourceAccountId !== undefined);
-    
+    const links = results
+      .map((result) => {
+        const normalized = result.sourceUser.username
+          .toLowerCase()
+          .replace(/[._-]/g, "");
+        const sourceAccountId = sourceAccountIdMap.get(normalized);
+        return {
+          sourceAccountId: sourceAccountId!,
+          sourceDate: result.sourceUser.date,
+        };
+      })
+      .filter((link) => link.sourceAccountId !== undefined);
+
     await bulkLinkUserToSourceAccounts(uploadId, userSession.did, links);
-    
+
     // BULK OPERATION 3: Store all atproto matches at once
     const allMatches: Array<{
       sourceAccountId: number;
···
       postCount: number;
       followerCount: number;
     }> = [];
-    
+
     const matchedSourceAccountIds: number[] = [];
-    
+
     for (const result of results) {
-      const normalized = result.sourceUser.username.toLowerCase().replace(/[._-]/g, '');
+      const normalized = result.sourceUser.username
+        .toLowerCase()
+        .replace(/[._-]/g, "");
       const sourceAccountId = sourceAccountIdMap.get(normalized);
-      
-      if (sourceAccountId && result.atprotoMatches && result.atprotoMatches.length > 0) {
+
+      if (
+        sourceAccountId &&
+        result.atprotoMatches &&
+        result.atprotoMatches.length > 0
+      ) {
         matchedCount++;
         matchedSourceAccountIds.push(sourceAccountId);
-        
+
         for (const match of result.atprotoMatches) {
           allMatches.push({
             sourceAccountId,
···
         }
       }
     }
-    
+
     // Store all matches in one operation
     let matchIdMap = new Map<string, number>();
     if (allMatches.length > 0) {
       matchIdMap = await bulkStoreAtprotoMatches(allMatches);
     }
-    
+
     // BULK OPERATION 4: Mark all matched source accounts
     if (matchedSourceAccountIds.length > 0) {
       await bulkMarkSourceAccountsMatched(matchedSourceAccountIds);
     }
-    
+
     // BULK OPERATION 5: Create all user match statuses
     const statuses: Array<{
       did: string;
···
       sourceAccountId: number;
       viewed: boolean;
     }> = [];
-    
+
     for (const match of allMatches) {
       const key = `${match.sourceAccountId}:${match.atprotoDid}`;
       const matchId = matchIdMap.get(key);
···
           did: userSession.did,
           atprotoMatchId: matchId,
           sourceAccountId: match.sourceAccountId,
-          viewed: true
+          viewed: true,
         });
       }
     }
-    
+
     if (statuses.length > 0) {
       await bulkCreateUserMatchStatus(statuses);
     }
 
     // Update upload record with final counts
     await sql`
-      UPDATE user_uploads 
+      UPDATE user_uploads
       SET matched_users = ${matchedCount},
           unmatched_users = ${results.length - matchedCount}
       WHERE upload_id = ${uploadId}
···
     return {
       statusCode: 200,
       headers: {
-        'Content-Type': 'application/json',
-        'Access-Control-Allow-Origin': '*',
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
       },
       body: JSON.stringify({
         success: true,
         uploadId,
         totalUsers: results.length,
         matchedUsers: matchedCount,
-        unmatchedUsers: results.length - matchedCount
+        unmatchedUsers: results.length - matchedCount,
       }),
     };
-
   } catch (error) {
-    console.error('Save results error:', error);
+    console.error("Save results error:", error);
     return {
       statusCode: 500,
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ 
-        error: 'Failed to save results',
-        details: error instanceof Error ? error.message : 'Unknown error'
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        error: "Failed to save results",
+        details: error instanceof Error ? error.message : "Unknown error",
       }),
     };
   }
-};
+};

netlify/functions/session.ts

···
-import { Handler, HandlerEvent, HandlerResponse } from '@netlify/functions';
-import { NodeOAuthClient, atprotoLoopbackClientMetadata } from '@atproto/oauth-client-node';
-import { JoseKey } from '@atproto/jwk-jose';
-import { stateStore, sessionStore, userSessions } from './oauth-stores-db';
-import { getOAuthConfig } from './oauth-config';
-import { Agent } from '@atproto/api';
-import cookie from 'cookie';
+import { Handler, HandlerEvent, HandlerResponse } from "@netlify/functions";
+import {
+  NodeOAuthClient,
+  atprotoLoopbackClientMetadata,
+} from "@atproto/oauth-client-node";
+import { JoseKey } from "@atproto/jwk-jose";
+import { stateStore, sessionStore, userSessions } from "./oauth-stores-db";
+import { getOAuthConfig } from "./oauth-config";
+import { Agent } from "@atproto/api";
+import cookie from "cookie";
 
 function normalizePrivateKey(key: string): string {
-  if (!key.includes('\n') && key.includes('\\n')) {
-    return key.replace(/\\n/g, '\n');
+  if (!key.includes("\n") && key.includes("\\n")) {
+    return key.replace(/\\n/g, "\n");
   }
   return key;
 }
···
 const PROFILE_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
 
 // Tier 2: Session metadata cache (DID -> basic info, faster than full OAuth restore)
-const sessionMetadataCache = new Map<string, { 
-  did: string; 
-  lastSeen: number;
-  profileFetchNeeded: boolean;
-}>();
+const sessionMetadataCache = new Map<
+  string,
+  {
+    did: string;
+    lastSeen: number;
+    profileFetchNeeded: boolean;
+  }
+>();
 
-export const handler: Handler = async (event: HandlerEvent): Promise<HandlerResponse> => {
+export const handler: Handler = async (
+  event: HandlerEvent,
+): Promise<HandlerResponse> => {
   try {
-    const cookies = event.headers.cookie ? cookie.parse(event.headers.cookie) : {};
-    const sessionId = event.queryStringParameters?.session || cookies.atlast_session;
+    const cookies = event.headers.cookie
+      ? cookie.parse(event.headers.cookie)
+      : {};
+    const sessionId =
+      event.queryStringParameters?.session || cookies.atlast_session;
 
     if (!sessionId) {
       return {
         statusCode: 401,
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ error: 'No session' }),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "No session" }),
       };
     }
 
     // OPTIMIZATION: Check session metadata cache first (avoids DB query)
     const cachedMetadata = sessionMetadataCache.get(sessionId);
     const now = Date.now();
-    
+
     let did: string;
-    
-    if (cachedMetadata && (now - cachedMetadata.lastSeen < 60000)) {
+
+    if (cachedMetadata && now - cachedMetadata.lastSeen < 60000) {
       // Session seen within last minute, trust the cache
       did = cachedMetadata.did;
-      console.log('Session metadata from cache');
+      console.log("Session metadata from cache");
     } else {
       // Need to verify session from database
       const userSession = await userSessions.get(sessionId);
···
         sessionMetadataCache.delete(sessionId);
         return {
           statusCode: 401,
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ error: 'Invalid or expired session' }),
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ error: "Invalid or expired session" }),
         };
       }
-      
+
       did = userSession.did;
-      
+
       // Update session metadata cache
       sessionMetadataCache.set(sessionId, {
         did,
         lastSeen: now,
-        profileFetchNeeded: true
+        profileFetchNeeded: true,
       });
-      
+
       // Cleanup: Remove old session metadata entries
       if (sessionMetadataCache.size > 200) {
         for (const [sid, meta] of sessionMetadataCache.entries()) {
-          if (now - meta.lastSeen > 300000) { // 5 minutes
+          if (now - meta.lastSeen > 300000) {
+            // 5 minutes
             sessionMetadataCache.delete(sid);
           }
         }
···
     // Check profile cache (Tier 1)
     const cached = profileCache.get(did);
     if (cached && now - cached.timestamp < PROFILE_CACHE_TTL) {
-      console.log('Returning cached profile for', did);
-      
+      console.log("Returning cached profile for", did);
+
       // Update session metadata last seen
       const meta = sessionMetadataCache.get(sessionId);
       if (meta) {
         meta.lastSeen = now;
       }
-      
+
       return {
         statusCode: 200,
         headers: {
-          'Content-Type': 'application/json',
-          'Access-Control-Allow-Origin': '*',
-          'Cache-Control': 'private, max-age=300', // Browser can cache for 5 minutes
-          'X-Cache-Status': 'HIT'
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+          "Cache-Control": "private, max-age=300", // Browser can cache for 5 minutes
+          "X-Cache-Status": "HIT",
         },
         body: JSON.stringify(cached.data),
       };
···
     // Cache miss - fetch full profile
     try {
       const config = getOAuthConfig();
-      const isDev = config.clientType === 'loopback';
+      const isDev = config.clientType === "loopback";
 
       let client: NodeOAuthClient;
 
···
         });
       } else {
         // Production with private key
-        const normalizedKey = normalizePrivateKey(process.env.OAUTH_PRIVATE_KEY!);
-        const privateKey = await JoseKey.fromImportable(normalizedKey, 'main-key');
+        const normalizedKey = normalizePrivateKey(
+          process.env.OAUTH_PRIVATE_KEY!,
+        );
+        const privateKey = await JoseKey.fromImportable(
+          normalizedKey,
+          "main-key",
+        );
 
         client = new NodeOAuthClient({
           clientMetadata: {
             client_id: config.clientId,
-            client_name: 'ATlast',
-            client_uri: config.clientId.replace('/client-metadata.json', ''),
+            client_name: "ATlast",
+            client_uri: config.clientId.replace("/client-metadata.json", ""),
             redirect_uris: [config.redirectUri],
-            scope: 'atproto transition:generic',
-            grant_types: ['authorization_code', 'refresh_token'],
-            response_types: ['code'],
-            application_type: 'web',
-            token_endpoint_auth_method: 'private_key_jwt',
-            token_endpoint_auth_signing_alg: 'ES256',
+            scope: "atproto transition:generic",
+            grant_types: ["authorization_code", "refresh_token"],
+            response_types: ["code"],
+            application_type: "web",
+            token_endpoint_auth_method: "private_key_jwt",
+            token_endpoint_auth_signing_alg: "ES256",
             dpop_bound_access_tokens: true,
             jwks_uri: config.jwksUri,
           },
···
 
       // Restore OAuth session
       const oauthSession = await client.restore(did);
-      
+
       // Create agent from OAuth session
       const agent = new Agent(oauthSession);
 
···
       return {
         statusCode: 200,
         headers: {
-          'Content-Type': 'application/json',
-          'Access-Control-Allow-Origin': '*',
-          'Cache-Control': 'private, max-age=300',
-          'X-Cache-Status': 'MISS'
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+          "Cache-Control": "private, max-age=300",
+          "X-Cache-Status": "MISS",
         },
         body: JSON.stringify(profileData),
       };
     } catch (error) {
-      console.error('Profile fetch error:', error);
-      
+      console.error("Profile fetch error:", error);
+
       // If profile fetch fails, return basic session info
       return {
         statusCode: 200,
         headers: {
-          'Content-Type': 'application/json',
-          'Access-Control-Allow-Origin': '*',
-          'X-Cache-Status': 'ERROR'
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+          "X-Cache-Status": "ERROR",
         },
         body: JSON.stringify({
           did: did,
···
       };
     }
   } catch (error) {
-    console.error('Session error:', error);
+    console.error("Session error:", error);
     return {
       statusCode: 500,
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ error: 'Internal server error' }),
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ error: "Internal server error" }),
     };
   }
-};
+};