commit 151c5b02528b112e51d45b80b630319bce2c6529 · knotbin.com/airport

-112

auth/creds/sessions.ts

···

       1
       1
       -
       import { Agent } from "npm:@atproto/api";

     

       2
       2
       -
       import { getIronSession, SessionOptions } from "npm:iron-session";

     

       3
       3
       -
       import { CredentialSession, createSessionOptions } from "../types.ts";

     

       4
       4
       -
       

     

       5
       5
       -
       const migrationSessionOptions = createSessionOptions("migration_sid");

     

       6
       6
       -
       const credentialSessionOptions = createSessionOptions("cred_sid");

     

       7
       7
       -
       

     

       8
       8
       -
       export function getCredentialSession(

     

       9
       9
       -
         req: Request,

     

       10
       10
       -
         res: Response = new Response(),

     

       11
       11
       -
         options: SessionOptions

     

       12
       12
       -
       ) {

     

       13
       13
       -
         return getIronSession<CredentialSession>(

     

       14
       14
       -
           req,

     

       15
       15
       -
           res,

     

       16
       16
       -
           options,

     

       17
       17
       -
         );

     

       18
       18
       -
       }

     

       19
       19
       -
       

     

       20
       20
       -
       export async function getCredentialAgent(

     

       21
       21
       -
         req: Request,

     

       22
       22
       -
         res: Response = new Response(),

     

       23
       23
       -
         isMigration: boolean = false,

     

       24
       24
       -
       ) {

     

       25
       25
       -
         const session = await getCredentialSession(

     

       26
       26
       -
           req,

     

       27
       27
       -
           res,

     

       28
       28
       -
           isMigration ?

     

       29
       29
       -
           migrationSessionOptions : credentialSessionOptions

     

       30
       30
       -
         );

     

       31
       31
       -
         if (!session.did || !session.service) {

     

       32
       32
       -
           return null;

     

       33
       33
       -
         }

     

       34
       34
       -
       

     

       35
       35
       -
         try {

     

       36
       36
       -
           return new Agent({

     

       37
       37
       -
             service: session.service,

     

       38
       38
       -
           });

     

       39
       39
       -
         } catch (err) {

     

       40
       40
       -
           console.warn("Failed to create migration agent:", err);

     

       41
       41
       -
           session.destroy();

     

       42
       42
       -
           return null;

     

       43
       43
       -
         }

     

       44
       44
       -
       }

     

       45
       45
       -
       

     

       46
       46
       -
       export async function setCredentialSession(

     

       47
       47
       -
         req: Request,

     

       48
       48
       -
         res: Response,

     

       49
       49
       -
         data: CredentialSession,

     

       50
       50
       -
         isMigration: boolean = false,

     

       51
       51
       -
       ) {

     

       52
       52
       -
         const session = await getCredentialSession(

     

       53
       53
       -
           req,

     

       54
       54
       -
           res,

     

       55
       55
       -
           isMigration ?

     

       56
       56
       -
           migrationSessionOptions : credentialSessionOptions

     

       57
       57
       -
         );

     

       58
       58
       -
         session.did = data.did;

     

       59
       59
       -
         session.handle = data.handle;

     

       60
       60
       -
         session.service = data.service;

     

       61
       61
       -
         session.password = data.password;

     

       62
       62
       -
         await session.save();

     

       63
       63
       -
         return session;

     

       64
       64
       -
       }

     

       65
       65
       -
       

     

       66
       66
       -
       export async function getCredentialSessionAgent(

     

       67
       67
       -
         req: Request,

     

       68
       68
       -
         res: Response = new Response(),

     

       69
       69
       -
         isMigration: boolean = false,

     

       70
       70
       -
       ) {

     

       71
       71
       -
         const session = await getCredentialSession(

     

       72
       72
       -
           req,

     

       73
       73
       -
           res,

     

       74
       74
       -
           isMigration ?

     

       75
       75
       -
           migrationSessionOptions : credentialSessionOptions

     

       76
       76
       -
         );

     

       77
       77
       -
       

     

       78
       78
       -
         if (

     

       79
       79
       -
           !session.did || !session.service || !session.handle || !session.password

     

       80
       80
       -
         ) {

     

       81
       81
       -
           return null;

     

       82
       82
       -
         }

     

       83
       83
       -
       

     

       84
       84
       -
         try {

     

       85
       85
       -
           console.log("Creating agent with service:", session.service);

     

       86
       86
       -
           const agent = new Agent({ service: session.service });

     

       87
       87
       -
       

     

       88
       88
       -
           // Attempt to restore session by creating a new one

     

       89
       89
       -
           try {

     

       90
       90
       -
             console.log("Attempting to create session for:", session.handle);

     

       91
       91
       -
             const sessionRes = await agent.com.atproto.server.createSession({

     

       92
       92
       -
               identifier: session.handle,

     

       93
       93
       -
               password: session.password,

     

       94
       94
       -
             });

     

       95
       95
       -
             console.log("Session created successfully:", !!sessionRes);

     

       96
       96
       -
       

     

       97
       97
       -
             // Set the auth tokens in the agent

     

       98
       98
       -
             agent.setHeader("Authorization", `Bearer ${sessionRes.data.accessJwt}`);

     

       99
       99
       -
       

     

       100
       100
       -
             return agent;

     

       101
       101
       -
           } catch (err) {

     

       102
       102
       -
             // Session creation failed, clear the session

     

       103
       103
       -
             console.error("Failed to create session:", err);

     

       104
       104
       -
             session.destroy();

     

       105
       105
       -
             return null;

     

       106
       106
       -
           }

     

       107
       107
       -
         } catch (err) {

     

       108
       108
       -
           console.warn("Failed to create migration agent:", err);

     

       109
       109
       -
           session.destroy();

     

       110
       110
       -
           return null;

     

       111
       111
       -
         }

     

       112
       112
       -
       }

auth/oauth/client.ts lib/oauth/client.ts

auth/oauth/sessions.ts lib/oauth/sessions.ts

-51

auth/sessions.ts

···

       1
       1
       -
       import { Agent } from "npm:@atproto/api";

     

       2
       2
       -
       import { OauthSession, CredentialSession, createSessionOptions } from "./types.ts";

     

       3
       3
       -
       import { getCredentialSession, getCredentialSessionAgent } from "./creds/sessions.ts";

     

       4
       4
       -
       import { getOauthSession, getOauthSessionAgent } from "./oauth/sessions.ts";

     

       5
       5
       -
       import { IronSession } from "npm:iron-session";

     

       6
       6
       -
       

     

       7
       7
       -
       const migrationSessionOptions = createSessionOptions("migration_sid");

     

       8
       8
       -
       const credentialSessionOptions = createSessionOptions("cred_sid");

     

       9
       9
       -
       

     

       10
       10
       -
       export async function getSession(

     

       11
       11
       -
         req: Request,

     

       12
       12
       -
         res: Response = new Response(),

     

       13
       13
       -
         isMigration: boolean = false

     

       14
       14
       -
       ): Promise<IronSession<OauthSession | CredentialSession>> {

     

       15
       15
       -
         if (isMigration) {

     

       16
       16
       -
           return await getCredentialSession(req, res, migrationSessionOptions);

     

       17
       17
       -
         }

     

       18
       18
       -
         const oauthSession = await getOauthSession(req);

     

       19
       19
       -
         const credentialSession = await getCredentialSession(req, res, credentialSessionOptions);

     

       20
       20
       -
       

     

       21
       21
       -
         if (oauthSession) {

     

       22
       22
       -
           console.log("Oauth session found")

     

       23
       23
       -
           return oauthSession;

     

       24
       24
       -
         }

     

       25
       25
       -
         if (credentialSession) {

     

       26
       26
       -
           return credentialSession;

     

       27
       27
       -
         }

     

       28
       28
       -
       

     

       29
       29
       -
         throw new Error("No session found");

     

       30
       30
       -
       }

     

       31
       31
       -
       

     

       32
       32
       -
       export async function getSessionAgent(

     

       33
       33
       -
         req: Request,

     

       34
       34
       -
         res: Response = new Response(),

     

       35
       35
       -
         isMigration: boolean = false

     

       36
       36
       -
       ): Promise<Agent | null> {

     

       37
       37
       -
         if (isMigration) {

     

       38
       38
       -
           return await getCredentialSessionAgent(req, res, isMigration);

     

       39
       39
       -
         }

     

       40
       40
       -
       

     

       41
       41
       -
         const oauthAgent = await getOauthSessionAgent(req);

     

       42
       42
       -
         if (oauthAgent) {

     

       43
       43
       -
           return oauthAgent;

     

       44
       44
       -
         }

     

       45
       45
       -
         const credentialAgent = await getCredentialSessionAgent(req, res, isMigration);

     

       46
       46
       -
         if (credentialAgent) {

     

       47
       47
       -
           return credentialAgent;

     

       48
       48
       -
         }

     

       49
       49
       -
       

     

       50
       50
       -
         return null;

     

       51
       51
       -
       }

auth/storage.ts lib/storage.ts

+8 -12

auth/types.ts lib/types.ts

···

       1
       1
        
       import { SessionOptions } from "npm:iron-session";

     

       2
       2
       +
       import { AtpSessionData } from "@atproto/api";

     

       2
       3
        
       

     

       3
       4
        
       export interface OauthSession {

     

       4
       5
        
         did: string

     

       5
       6
        
       }

     

       6
       7
        
       

     

       7
       7
       -
       export interface CredentialSession {

     

       8
       8
       -
         did: string;

     

       9
       9
       -
         handle: string;

     

       10
       10
       -
         service: string;

     

       11
       11
       -
         password: string;

     

       12
       12
       -
         recoveryKey?: string;

     

       13
       13
       -
         recoveryKeyDid?: string;

     

       14
       14
       -
         credentials?: {

     

       15
       15
       -
           rotationKeys: string[];

     

       16
       16
       -
           [key: string]: unknown;

     

       17
       17
       -
         };

     

       8
       8
       +
       export type Credentials = {

     

       9
       9
       +
         service: string,

     

       10
       10
       +
         did: string,

     

       11
       11
       +
         password: string

     

       18
       12
        
       }

     

       13
       13
       +
       

     

       14
       14
       +
       export type CredSession = AtpSessionData & { service: string }

     

       19
       15
        
       

     

       20
       16
        
       export const createSessionOptions = (cookieName: string): SessionOptions =>  {

     

       21
       17
        
           const cookieSecret = Deno.env.get("COOKIE_SECRET");

     
···

       34
       30
        
                   domain: undefined,

     

       35
       31
        
               },

     

       36
       32
        
           }

     

       37
       37
       -
       };
     

       33
       33
       +
       };

+124

islands/CredLogin.tsx

···

       1
       1
       +
       import { useState } from 'preact/hooks'

     

       2
       2
       +
       import { JSX } from 'preact'

     

       3
       3
       +
       

     

       4
       4
       +
       export default function CredLogin() {

     

       5
       5
       +
         const [handle, setHandle] = useState('')

     

       6
       6
       +
         const [password, setPassword] = useState('')

     

       7
       7
       +
         const [error, setError] = useState<string | null>(null)

     

       8
       8
       +
         const [isPending, setIsPending] = useState(false)

     

       9
       9
       +
       

     

       10
       10
       +
         const handleSubmit = async (e: JSX.TargetedEvent<HTMLFormElement>) => {

     

       11
       11
       +
           e.preventDefault()

     

       12
       12
       +
           if (!handle.trim() || !password.trim()) return

     

       13
       13
       +
       

     

       14
       14
       +
           setError(null)

     

       15
       15
       +
           setIsPending(true)

     

       16
       16
       +
       

     

       17
       17
       +
           try {

     

       18
       18
       +
             const response = await fetch('/api/cred/login', {

     

       19
       19
       +
               method: 'POST',

     

       20
       20
       +
               headers: {

     

       21
       21
       +
                 'Content-Type': 'application/json',

     

       22
       22
       +
               },

     

       23
       23
       +
               body: JSON.stringify({ handle, password }),

     

       24
       24
       +
             })

     

       25
       25
       +
       

     

       26
       26
       +
             if (!response.ok) {

     

       27
       27
       +
               const errorText = await response.text()

     

       28
       28
       +
               throw new Error(errorText || 'Login failed')

     

       29
       29
       +
             }

     

       30
       30
       +
       

     

       31
       31
       +
             // Add a small delay before redirecting for better UX

     

       32
       32
       +
             await new Promise((resolve) => setTimeout(resolve, 500))

     

       33
       33
       +
       

     

       34
       34
       +
             // Redirect to home page after successful login

     

       35
       35
       +
             globalThis.location.href = '/'

     

       36
       36
       +
           } catch (err) {

     

       37
       37
       +
             const message = err instanceof Error ? err.message : 'Login failed'

     

       38
       38
       +
             setError(message)

     

       39
       39
       +
           } finally {

     

       40
       40
       +
             setIsPending(false)

     

       41
       41
       +
           }

     

       42
       42
       +
         }

     

       43
       43
       +
       

     

       44
       44
       +
         return (

     

       45
       45
       +
           <form onSubmit={handleSubmit}>

     

       46
       46
       +
             {error && (

     

       47
       47
       +
               <div className="text-red-500 mb-4 p-2 bg-red-50 dark:bg-red-950 dark:bg-opacity-30 rounded-md">

     

       48
       48
       +
                 {error}

     

       49
       49
       +
               </div>

     

       50
       50
       +
             )}

     

       51
       51
       +
       

     

       52
       52
       +
             <div className="mb-4">

     

       53
       53
       +
               <label

     

       54
       54
       +
                 htmlFor="handle"

     

       55
       55
       +
                 className="block mb-2 text-gray-700 dark:text-gray-300"

     

       56
       56
       +
               >

     

       57
       57
       +
                 Enter your Bluesky handle:

     

       58
       58
       +
               </label>

     

       59
       59
       +
               <input

     

       60
       60
       +
                 id="handle"

     

       61
       61
       +
                 type="text"

     

       62
       62
       +
                 value={handle}

     

       63
       63
       +
                 onInput={(e) => setHandle((e.target as HTMLInputElement).value)}

     

       64
       64
       +
                 placeholder="example.bsky.social"

     

       65
       65
       +
                 disabled={isPending}

     

       66
       66
       +
                 className="w-full p-3 border border-gray-300 dark:border-gray-700 bg-white dark:bg-gray-700 text-gray-900 dark:text-gray-100 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-300 dark:focus:ring-blue-500 transition-colors"

     

       67
       67
       +
               />

     

       68
       68
       +
             </div>

     

       69
       69
       +
       

     

       70
       70
       +
             <div className="mb-4">

     

       71
       71
       +
               <label

     

       72
       72
       +
                 htmlFor="password"

     

       73
       73
       +
                 className="block mb-2 text-gray-700 dark:text-gray-300"

     

       74
       74
       +
               >

     

       75
       75
       +
                 Password:

     

       76
       76
       +
               </label>

     

       77
       77
       +
               <input

     

       78
       78
       +
                 id="password"

     

       79
       79
       +
                 type="password"

     

       80
       80
       +
                 value={password}

     

       81
       81
       +
                 onInput={(e) => setPassword((e.target as HTMLInputElement).value)}

     

       82
       82
       +
                 placeholder="Enter your password"

     

       83
       83
       +
                 disabled={isPending}

     

       84
       84
       +
                 className="w-full p-3 border border-gray-300 dark:border-gray-700 bg-white dark:bg-gray-700 text-gray-900 dark:text-gray-100 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-300 dark:focus:ring-blue-500 transition-colors"

     

       85
       85
       +
               />

     

       86
       86
       +
             </div>

     

       87
       87
       +
       

     

       88
       88
       +
             <button

     

       89
       89
       +
               type="submit"

     

       90
       90
       +
               disabled={isPending}

     

       91
       91
       +
               className={`w-full px-4 py-2 rounded-md bg-blue-500 dark:bg-blue-600 text-white font-medium hover:bg-blue-600 dark:hover:bg-blue-700 transition-colors focus:outline-none focus:ring-2 focus:ring-blue-300 dark:focus:ring-blue-500 relative ${

     

       92
       92
       +
                 isPending ? 'opacity-90 cursor-not-allowed' : ''

     

       93
       93
       +
               }`}

     

       94
       94
       +
             >

     

       95
       95
       +
               <span className={isPending ? 'invisible' : ''}>Login with Password</span>

     

       96
       96
       +
               {isPending && (

     

       97
       97
       +
                 <span className="absolute inset-0 flex items-center justify-center">

     

       98
       98
       +
                   <svg

     

       99
       99
       +
                     className="animate-spin -ml-1 mr-2 h-5 w-5 text-white"

     

       100
       100
       +
                     xmlns="http://www.w3.org/2000/svg"

     

       101
       101
       +
                     fill="none"

     

       102
       102
       +
                     viewBox="0 0 24 24"

     

       103
       103
       +
                   >

     

       104
       104
       +
                     <circle

     

       105
       105
       +
                       className="opacity-25"

     

       106
       106
       +
                       cx="12"

     

       107
       107
       +
                       cy="12"

     

       108
       108
       +
                       r="10"

     

       109
       109
       +
                       stroke="currentColor"

     

       110
       110
       +
                       strokeWidth="4"

     

       111
       111
       +
                     ></circle>

     

       112
       112
       +
                     <path

     

       113
       113
       +
                       className="opacity-75"

     

       114
       114
       +
                       fill="currentColor"

     

       115
       115
       +
                       d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"

     

       116
       116
       +
                     ></path>

     

       117
       117
       +
                   </svg>

     

       118
       118
       +
                   <span>Logging in...</span>

     

       119
       119
       +
                 </span>

     

       120
       120
       +
               )}

     

       121
       121
       +
             </button>

     

       122
       122
       +
           </form>

     

       123
       123
       +
         )

     

       124
       124
       +
       }

+51

islands/LoginSelector.tsx

···

       1
       1
       +
       import { useState } from "preact/hooks"

     

       2
       2
       +
       import HandleInput from "./HandleInput.tsx"

     

       3
       3
       +
       import CredLogin from "./CredLogin.tsx"

     

       4
       4
       +
       

     

       5
       5
       +
       export default function LoginMethodSelector() {

     

       6
       6
       +
         const [loginMethod, setLoginMethod] = useState<'oauth' | 'password'>('password')

     

       7
       7
       +
       

     

       8
       8
       +
         return (

     

       9
       9
       +
           <div className="flex flex-col gap-8">

     

       10
       10
       +
             <div className="bg-white dark:bg-gray-800 rounded-lg p-6 shadow-sm max-w-md mx-auto w-full">

     

       11
       11
       +
               <h2 className="text-xl font-semibold mb-4">Login with ATProto</h2>

     

       12
       12
       +
       

     

       13
       13
       +
               <div className="flex gap-4 mb-6">

     

       14
       14
       +
                 <button

     

       15
       15
       +
                   type="button"

     

       16
       16
       +
                   onClick={() => setLoginMethod('oauth')}

     

       17
       17
       +
                   className={`flex-1 px-4 py-2 rounded-md transition-colors ${

     

       18
       18
       +
                     loginMethod === 'oauth'

     

       19
       19
       +
                       ? 'bg-blue-500 text-white'

     

       20
       20
       +
                       : 'bg-gray-100 dark:bg-gray-700 text-gray-700 dark:text-gray-300'

     

       21
       21
       +
                   }`}

     

       22
       22
       +
                 >

     

       23
       23
       +
                   OAuth

     

       24
       24
       +
                 </button>

     

       25
       25
       +
                 <button

     

       26
       26
       +
                   type="button"

     

       27
       27
       +
                   onClick={() => setLoginMethod('password')}

     

       28
       28
       +
                   className={`flex-1 px-4 py-2 rounded-md transition-colors ${

     

       29
       29
       +
                     loginMethod === 'password'

     

       30
       30
       +
                       ? 'bg-blue-500 text-white'

     

       31
       31
       +
                       : 'bg-gray-100 dark:bg-gray-700 text-gray-700 dark:text-gray-300'

     

       32
       32
       +
                   }`}

     

       33
       33
       +
                 >

     

       34
       34
       +
                   Credential

     

       35
       35
       +
                 </button>

     

       36
       36
       +
               </div>

     

       37
       37
       +
       

     

       38
       38
       +
               {loginMethod === 'oauth' ? <HandleInput /> : <CredLogin />}

     

       39
       39
       +
       

     

       40
       40
       +
               <div className="mt-4 text-center">

     

       41
       41
       +
                 <a

     

       42
       42
       +
                   href="/"

     

       43
       43
       +
                   className="text-blue-500 dark:text-blue-400 hover:text-blue-700 dark:hover:text-blue-300 transition-colors"

     

       44
       44
       +
                 >

     

       45
       45
       +
                   Cancel

     

       46
       46
       +
                 </a>

     

       47
       47
       +
               </div>

     

       48
       48
       +
             </div>

     

       49
       49
       +
           </div>

     

       50
       50
       +
         )

     

       51
       51
       +
       }

+71

lib/cred/sessions.ts

···

       1
       1
       +
       import { CredentialSession } from "npm:@atproto/api";

     

       2
       2
       +
       import { getIronSession } from "npm:iron-session";

     

       3
       3
       +
       import { CredSession, Credentials, createSessionOptions } from "../types.ts";

     

       4
       4
       +
       import { AtpAgent } from "@atproto/api";

     

       5
       5
       +
       

     

       6
       6
       +
       const credentialSessionOptions = createSessionOptions("cred_sid");

     

       7
       7
       +
       

     

       8
       8
       +
       export function getCredentialSession(

     

       9
       9
       +
         req: Request,

     

       10
       10
       +
         res: Response = new Response()

     

       11
       11
       +
       ) {

     

       12
       12
       +
         return getIronSession<CredSession>(

     

       13
       13
       +
           req,

     

       14
       14
       +
           res,

     

       15
       15
       +
           credentialSessionOptions,

     

       16
       16
       +
         );

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       export async function setCredentialSession(

     

       20
       20
       +
         req: Request,

     

       21
       21
       +
         res: Response,

     

       22
       22
       +
         data: Credentials

     

       23
       23
       +
       ) {

     

       24
       24
       +
         const session = await getCredentialSession(

     

       25
       25
       +
           req,

     

       26
       26
       +
           res

     

       27
       27
       +
         );

     

       28
       28
       +
       

     

       29
       29
       +
         const credSession = new CredentialSession(new URL(data.service))

     

       30
       30
       +
         const loginResponse = await credSession.login({

     

       31
       31
       +
           identifier: data.did,

     

       32
       32
       +
           password: data.password

     

       33
       33
       +
         })

     

       34
       34
       +
       

     

       35
       35
       +
         session.did = data.did;

     

       36
       36
       +
         session.service = data.service;

     

       37
       37
       +
         session.refreshJwt = loginResponse.data.refreshJwt;

     

       38
       38
       +
         session.accessJwt = loginResponse.data.accessJwt;

     

       39
       39
       +
         session.active = loginResponse.data.active ?? true;

     

       40
       40
       +
         session.handle = loginResponse.data.handle;

     

       41
       41
       +
       

     

       42
       42
       +
         await session.save();

     

       43
       43
       +
         return session;

     

       44
       44
       +
       }

     

       45
       45
       +
       

     

       46
       46
       +
       export async function getCredentialSessionAgent(

     

       47
       47
       +
         req: Request,

     

       48
       48
       +
         res: Response = new Response()

     

       49
       49
       +
       ) {

     

       50
       50
       +
         const session = await getCredentialSession(

     

       51
       51
       +
           req,

     

       52
       52
       +
           res

     

       53
       53
       +
         );

     

       54
       54
       +
       

     

       55
       55
       +
         if (

     

       56
       56
       +
           !session.did || !session.service

     

       57
       57
       +
         ) {

     

       58
       58
       +
           return null;

     

       59
       59
       +
         }

     

       60
       60
       +
       

     

       61
       61
       +
         try {

     

       62
       62
       +
           console.log("Creating agent with service:", session.service);

     

       63
       63
       +
           const agent = new AtpAgent(session);

     

       64
       64
       +
           agent.resumeSession(session)

     

       65
       65
       +
           return agent;

     

       66
       66
       +
         } catch (err) {

     

       67
       67
       +
           console.warn("Failed to create migration agent:", err);

     

       68
       68
       +
           session.destroy();

     

       69
       69
       +
           return null;

     

       70
       70
       +
         }

     

       71
       71
       +
       }

+39

lib/sessions.ts

···

       1
       1
       +
       import { Agent } from "npm:@atproto/api";

     

       2
       2
       +
       import { OauthSession, CredSession } from "./types.ts";

     

       3
       3
       +
       import { getCredentialSession, getCredentialSessionAgent } from "./cred/sessions.ts";

     

       4
       4
       +
       import { getOauthSession, getOauthSessionAgent } from "./oauth/sessions.ts";

     

       5
       5
       +
       import { IronSession } from "npm:iron-session";

     

       6
       6
       +
       

     

       7
       7
       +
       export async function getSession(

     

       8
       8
       +
         req: Request,

     

       9
       9
       +
         res: Response = new Response(),

     

       10
       10
       +
       ): Promise<IronSession<OauthSession | CredSession>> {

     

       11
       11
       +
         const oauthSession = await getOauthSession(req);

     

       12
       12
       +
         const credentialSession = await getCredentialSession(req, res);

     

       13
       13
       +
       

     

       14
       14
       +
         if (oauthSession) {

     

       15
       15
       +
           console.log("Oauth session found")

     

       16
       16
       +
           return oauthSession;

     

       17
       17
       +
         }

     

       18
       18
       +
         if (credentialSession) {

     

       19
       19
       +
           return credentialSession;

     

       20
       20
       +
         }

     

       21
       21
       +
       

     

       22
       22
       +
         throw new Error("No session found");

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       export async function getSessionAgent(

     

       26
       26
       +
         req: Request,

     

       27
       27
       +
         res: Response = new Response(),

     

       28
       28
       +
       ): Promise<Agent | null> {

     

       29
       29
       +
         const oauthAgent = await getOauthSessionAgent(req);

     

       30
       30
       +
         if (oauthAgent) {

     

       31
       31
       +
           return oauthAgent;

     

       32
       32
       +
         }

     

       33
       33
       +
         const credentialAgent = await getCredentialSessionAgent(req, res);

     

       34
       34
       +
         if (credentialAgent) {

     

       35
       35
       +
           return credentialAgent;

     

       36
       36
       +
         }

     

       37
       37
       +
       

     

       38
       38
       +
         return null;

     

       39
       39
       +
       }

+69

routes/api/cred/login.ts

···

       1
       1
       +
       import { setCredentialSession } from "../../../lib/cred/sessions.ts";

     

       2
       2
       +
       import { resolver } from "../../../lib/id-resolver.ts";

     

       3
       3
       +
       import { define } from "../../../utils.ts";

     

       4
       4
       +
       

     

       5
       5
       +
       export const handler = define.handlers({

     

       6
       6
       +
         async POST(ctx) {

     

       7
       7
       +
           try {

     

       8
       8
       +
             const body = await ctx.req.json();

     

       9
       9
       +
             const { handle, password } = body;

     

       10
       10
       +
       

     

       11
       11
       +
             if (!handle || !password) {

     

       12
       12
       +
               return new Response(JSON.stringify({

     

       13
       13
       +
                 success: false,

     

       14
       14
       +
                 message: "Handle and password are required"

     

       15
       15
       +
               }), {

     

       16
       16
       +
                 status: 400,

     

       17
       17
       +
                 headers: { "Content-Type": "application/json" }

     

       18
       18
       +
               });

     

       19
       19
       +
             }

     

       20
       20
       +
             const did = await resolver.resolveHandleToDid(handle)

     

       21
       21
       +
             const service = await resolver.resolveDidToPdsUrl(did)

     

       22
       22
       +
       

     

       23
       23
       +
             if (!service) {

     

       24
       24
       +
               return new Response(JSON.stringify({

     

       25
       25
       +
                 success: false,

     

       26
       26
       +
                 message: "Invalid handle"

     

       27
       27
       +
               }), {

     

       28
       28
       +
                 status: 400,

     

       29
       29
       +
               })

     

       30
       30
       +
             }

     

       31
       31
       +
       

     

       32
       32
       +
             try {

     

       33
       33
       +
               // Create response for setting cookies

     

       34
       34
       +
               const response = new Response(JSON.stringify({

     

       35
       35
       +
                 success: true,

     

       36
       36
       +
                 did,

     

       37
       37
       +
                 handle

     

       38
       38
       +
               }), {

     

       39
       39
       +
                 status: 200,

     

       40
       40
       +
                 headers: { "Content-Type": "application/json" }

     

       41
       41
       +
               });

     

       42
       42
       +
               // Create and save our client session with tokens

     

       43
       43
       +
               await setCredentialSession(ctx.req, response, {

     

       44
       44
       +
                 did,

     

       45
       45
       +
                 service,

     

       46
       46
       +
                 password

     

       47
       47
       +
               });

     

       48
       48
       +
       

     

       49
       49
       +
               return response;

     

       50
       50
       +
             } catch {

     

       51
       51
       +
               return new Response(JSON.stringify({

     

       52
       52
       +
                 success: false,

     

       53
       53
       +
                 message: "Invalid credentials"

     

       54
       54
       +
               }), {

     

       55
       55
       +
                 status: 401,

     

       56
       56
       +
                 headers: { "Content-Type": "application/json" }

     

       57
       57
       +
               });

     

       58
       58
       +
             }

     

       59
       59
       +
           } catch (error) {

     

       60
       60
       +
             return new Response(JSON.stringify({

     

       61
       61
       +
               success: false,

     

       62
       62
       +
               message: error instanceof Error ? error.message : "An error occurred"

     

       63
       63
       +
             }), {

     

       64
       64
       +
               status: 500,

     

       65
       65
       +
               headers: { "Content-Type": "application/json" }

     

       66
       66
       +
             });

     

       67
       67
       +
           }

     

       68
       68
       +
         }

     

       69
       69
       +
       });

+12 -3

routes/api/me.ts

···

       1
       1
       -
       import { getSessionAgent } from "../../auth/sessions.ts";

     

       1
       1
       +
       import { getSessionAgent } from "../../lib/sessions.ts";

     

       2
       2
       +
       import { resolver } from "../../lib/id-resolver.ts";

     

       2
       3
        
       import { define } from "../../utils.ts";

     

       3
       3
       -
       import { resolver } from "../../tools/id-resolver.ts";

     

       4
       4
        
       

     

       5
       5
        
       export const handler = define.handlers({

     

       6
       6
        
         async GET(ctx) {

     
···

       12
       12
        
           }

     

       13
       13
        
       

     

       14
       14
        
           try {

     

       15
       15
       -
             const did = agent.assertDid;

     

       15
       15
       +
             if (agent.assertDid) {

     

       16
       16
       +
               const did = agent.assertDid;

     

       17
       17
       +
               const handle = await resolver.resolveDidToHandle(did);

     

       18
       18
       +
       

     

       19
       19
       +
               return Response.json({ did, handle });

     

       20
       20
       +
             }

     

       21
       21
       +
       

     

       22
       22
       +
             const session = await agent.com.atproto.server.getSession();

     

       23
       23
       +
             const did = session.data.did

     

       16
       24
        
             const handle = await resolver.resolveDidToHandle(did);

     

       25
       25
       +
       

     

       17
       26
        
       

     

       18
       27
        
             return Response.json({ did, handle });

     

       19
       28
        
           } catch (err) {

+3 -9

routes/api/migrate/create.ts

···

       1
       1
       -
       import { getSessionAgent } from "../../../auth/sessions.ts";

     

       2
       2
       -
       import { setCredentialSession } from "../../../auth/creds/sessions.ts";

     

       1
       1
       +
       import { getSessionAgent } from "../../../lib/sessions.ts";

     

       2
       2
       +
       import { setCredentialSession } from "../../../lib/cred/sessions.ts";

     

       3
       3
        
       import { Agent } from "@atproto/api";

     

       4
       4
        
       import { define } from "../../../utils.ts";

     

       5
       5
        
       

     
···

       59
       59
        
               },

     

       60
       60
        
             );

     

       61
       61
        
       

     

       62
       62
       -
             // Create session and store it

     

       63
       63
       -
             const sessionRes = await newAgent.com.atproto.server.createSession({

     

       64
       64
       -
               identifier: newHandle,

     

       65
       65
       -
               password: newPassword,

     

       66
       66
       -
             });

     

       67
       67
       -
       

     

       68
       62
        
             // Store the migration session

     

       69
       63
        
             await setCredentialSession(ctx.req, res, {

     

       70
       70
       -
               did: sessionRes.data.did,

     

       64
       64
       +
               did: accountDid,

     

       71
       65
        
               handle: newHandle,

     

       72
       66
        
               service: serviceUrl,

     

       73
       67
        
               password: newPassword,

+4 -2

routes/api/migrate/data.ts

···

       1
       1
        
       import { define } from "../../../utils.ts";

     

       2
       2
        
       import {

     

       3
       3
        
         getSessionAgent,

     

       4
       4
       -
       } from "../../../auth/sessions.ts";

     

       4
       4
       +
       } from "../../../lib/sessions.ts";

     

       5
       5
        
       

     

       6
       6
        
       export const handler = define.handlers({

     

       7
       7
        
         async POST(ctx) {

     
···

       16
       16
        
             console.log("Data migration: Cookies present:", !!cookies);

     

       17
       17
        
             console.log("Data migration: Cookie header:", cookies);

     

       18
       18
        
       

     

       19
       19
       -
             const newAgent = await getSessionAgent(ctx.req, res, true);

     

       19
       19
       +
             const newAgent = await getSessionAgent(ctx.req, res, );

     

       20
       20
        
             console.log("Data migration: Got new agent:", !!newAgent);

     

       21
       21
        
       

     

       22
       22
        
             if (!oldAgent) {

     
···

       50
       50
        
             const repoRes = await oldAgent.com.atproto.sync.getRepo({

     

       51
       51
        
               did: accountDid,

     

       52
       52
        
             });

     

       53
       53
       +
             const session = await newAgent.com.atproto.server.getSession()

     

       54
       54
       +
             console.log("Data migration: session:", session)

     

       53
       55
        
             await newAgent.com.atproto.repo.importRepo(repoRes.data, {

     

       54
       56
        
               encoding: "application/vnd.ipld.car",

     

       55
       57
        
             });

+1 -1

routes/api/migrate/finalize.ts

···

       1
       1
       -
       import { getSessionAgent } from "../../../auth/sessions.ts";

     

       1
       1
       +
       import { getSessionAgent } from "../../../lib/sessions.ts";

     

       2
       2
        
       import { define } from "../../../utils.ts";

     

       3
       3
        
       

     

       4
       4
        
       export const handler = define.handlers({

+1 -1

routes/api/migrate/identity/request.ts

···

       1
       1
        
       import {

     

       2
       2
        
         getSessionAgent,

     

       3
       3
       -
       } from "../../../../auth/sessions.ts";

     

       3
       3
       +
       } from "../../../../lib/sessions.ts";

     

       4
       4
        
       import { define } from "../../../../utils.ts";

     

       5
       5
        
       

     

       6
       6
        
       export const handler = define.handlers({

+1 -1

routes/api/migrate/identity/sign.ts

···

       1
       1
        
       import {

     

       2
       2
        
         getSessionAgent,

     

       3
       3
       -
       } from "../../../../auth/sessions.ts";

     

       3
       3
       +
       } from "../../../../lib/sessions.ts";

     

       4
       4
        
       import { Secp256k1Keypair } from "npm:@atproto/crypto";

     

       5
       5
        
       import * as ui8 from "npm:uint8arrays";

     

       6
       6
        
       import { define } from "../../../../utils.ts";

+2 -2

routes/api/oauth/callback.ts

···

       1
       1
       -
       import { oauthClient } from "../../../auth/oauth/client.ts";

     

       2
       2
       -
       import { getOauthSession } from "../../../auth/oauth/sessions.ts";

     

       1
       1
       +
       import { oauthClient } from "../../../lib/oauth/client.ts";

     

       2
       2
       +
       import { getOauthSession } from "../../../lib/oauth/sessions.ts";

     

       3
       3
        
       import { define } from "../../../utils.ts";

     

       4
       4
        
       

     

       5
       5
        
       export const handler = define.handlers({

+1 -1

routes/api/oauth/initiate.ts

···

       1
       1
        
       import { isValidHandle } from 'npm:@atproto/syntax'

     

       2
       2
       -
       import { oauthClient } from "../../../auth/oauth/client.ts";

     

       2
       2
       +
       import { oauthClient } from "../../../lib/oauth/client.ts";

     

       3
       3
        
       import { define } from "../../../utils.ts";

     

       4
       4
        
       

     

       5
       5
        
       function isValidUrl(url: string): boolean {

+2 -2

routes/api/oauth/logout.ts

···

       1
       1
       -
       import { getSession } from "../../../auth/sessions.ts";

     

       2
       2
       -
       import { oauthClient } from "../../../auth/oauth/client.ts";

     

       1
       1
       +
       import { getSession } from "../../../lib/sessions.ts";

     

       2
       2
       +
       import { oauthClient } from "../../../lib/oauth/client.ts";

     

       3
       3
        
       import { define } from "../../../utils.ts";

     

       4
       4
        
       

     

       5
       5
        
       export const handler = define.handlers({

+1 -1

routes/api/server/describe.ts

···

       1
       1
        
       

     

       2
       2
        
       import { Agent } from "@atproto/api";

     

       3
       3
       -
       import { getSessionAgent } from "../../../auth/sessions.ts";

     

       3
       3
       +
       import { getSessionAgent } from "../../../lib/sessions.ts";

     

       4
       4
        
       import { define } from "../../../utils.ts";

     

       5
       5
        
       /**

     

       6
       6
        
        * Describe the server configuration and capabilities

+2 -16

routes/login/index.tsx

···

       1
       1
        
       import { PageProps } from "fresh";

     

       2
       2
       -
       

     

       3
       3
       -
       import HandleInput from "../../islands/HandleInput.tsx";

     

       2
       2
       +
       import LoginSelector from "../../islands/LoginSelector.tsx"

     

       4
       3
        
       

     

       5
       4
        
       export async function submitHandle(handle: string) {

     

       6
       5
        
         const response = await fetch("/api/oauth/initiate", {

     
···

       29
       28
        
         return (

     

       30
       29
        
           <>

     

       31
       30
        
             <div className="flex flex-col gap-8">

     

       32
       32
       -
               <div className="bg-white dark:bg-gray-800 rounded-lg p-6 shadow-sm max-w-md mx-auto w-full">

     

       33
       33
       -
                 <h2 className="text-xl font-semibold mb-4">Login with ATProto</h2>

     

       34
       34
       -
       

     

       35
       35
       -
                 <HandleInput />

     

       36
       36
       -
       

     

       37
       37
       -
                 <div className="mt-4 text-center">

     

       38
       38
       -
                   <a

     

       39
       39
       -
                     href="/"

     

       40
       40
       -
                     className="text-blue-500 dark:text-blue-400 hover:text-blue-700 dark:hover:text-blue-300 transition-colors"

     

       41
       41
       -
                   >

     

       42
       42
       -
                     Cancel

     

       43
       43
       -
                   </a>

     

       44
       44
       -
                 </div>

     

       45
       45
       -
               </div>

     

       31
       31
       +
               <LoginSelector />

     

       46
       32
        
             </div>

     

       47
       33
        
           </>

     

       48
       34
        
         );

+5

tools/id-resolver.ts lib/id-resolver.ts

···

       1
       1
        
       import { IdResolver } from "npm:@atproto/identity";

     

       2
       2
       +
       import { Did } from "npm:@atproto/api";

     

       2
       3
        
       

     

       3
       4
        
       interface AtprotoData {

     

       4
       5
        
         did: string;

     
···

       29
       30
        
               return didDoc.handle;

     

       30
       31
        
             }

     

       31
       32
        
             return did;

     

       33
       33
       +
           },

     

       34
       34
       +
       

     

       35
       35
       +
           async resolveHandleToDid(handle: string) {

     

       36
       36
       +
             return await resolver.handle.resolve(handle) as Did

     

       32
       37
        
           },

     

       33
       38
        
       

     

       34
       39
        
           async resolveDidToPdsUrl(did: string): Promise<string | undefined> {