···

       
20
       
 
       
  logger: pino.Logger

     

       
21
       
 
       
  oauthClient: NodeOAuthClient

     

       
22
       
 
       
  resolver: BidirectionalResolver

     

       
0
       
 
       

     

       
23
       
 
       
}

     

       
24
       
 
       


     

       
25
       
 
       
export async function createAppContext(): Promise<AppContext> {

     
···

       
36
       
 
       
    logger,

     

       
37
       
 
       
    oauthClient,

     

       
38
       
 
       
    resolver,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
39
       
 
       
  }

     

       
40
       
 
       
}

     

···

       
20
       
 
       
  logger: pino.Logger

     

       
21
       
 
       
  oauthClient: NodeOAuthClient

     

       
22
       
 
       
  resolver: BidirectionalResolver

     

       
23
       
+
       
  destroy: () => Promise<void>

     

       
24
       
 
       
}

     

       
25
       
 
       


     

       
26
       
 
       
export async function createAppContext(): Promise<AppContext> {

     
···

       
37
       
 
       
    logger,

     

       
38
       
 
       
    oauthClient,

     

       
39
       
 
       
    resolver,

     

       
40
       
+
       
    async destroy() {

     

       
41
       
+
       
      await ingester.destroy()

     

       
42
       
+
       
      await db.destroy()

     

       
43
       
+
       
    },

     

       
44
       
 
       
  }

     

       
45
       
 
       
}

     

···

       
1
       
-
       
import { createHttpTerminator } from 'http-terminator'

     

       
2
       
 
       
import { once } from 'node:events'

     

       
3
       
 
       


     

       
4
       
 
       
import { createAppContext } from '#/context'

     

       
5
       
 
       
import { env } from '#/env'

     

       
0
       
 
       

     

       
6
       
 
       
import { run } from '#/lib/process'

     

       
7
       
 
       
import { createRouter } from '#/routes'

     

       
8
       
-
       
import { startServer } from '#/lib/http'

     

       
9
       
 
       


     

       
10
       
 
       
run(async (killSignal) => {

     

       
11
       
 
       
  // Create the application context

     
···

       
31
       
 
       
  await terminate()

     

       
32
       
 
       


     

       
33
       
 
       
  // Close the firehose connection

     

       
34
       
-
       
  await ctx.ingester.destroy()

     

       
35
       
 
       
})

     

···

       
0
       
 
       

     

       
1
       
 
       
import { once } from 'node:events'

     

       
2
       
 
       


     

       
3
       
 
       
import { createAppContext } from '#/context'

     

       
4
       
 
       
import { env } from '#/env'

     

       
5
       
+
       
import { startServer } from '#/lib/http'

     

       
6
       
 
       
import { run } from '#/lib/process'

     

       
7
       
 
       
import { createRouter } from '#/routes'

     

       
0
       
 
       

     

       
8
       
 
       


     

       
9
       
 
       
run(async (killSignal) => {

     

       
10
       
 
       
  // Create the application context

     
···

       
30
       
 
       
  await terminate()

     

       
31
       
 
       


     

       
32
       
 
       
  // Close the firehose connection

     

       
33
       
+
       
  await ctx.destroy()

     

       
34
       
 
       
})

     

···

       
9
       
 
       


     

       
10
       
 
       
export type NextFunction = (err?: unknown) => void

     

       
11
       
 
       


     

       
12
       
-
       
export type Handler<

     

       
13
       
 
       
  Req extends IncomingMessage = IncomingMessage,

     

       
14
       
 
       
  Res extends ServerResponse<Req> = ServerResponse<Req>,

     

       
15
       
 
       
> = (req: Req, res: Res, next: NextFunction) => void

     

       
16
       
 
       


     

       
17
       
-
       
export type AsyncHandler<

     

       
18
       
 
       
  Req extends IncomingMessage = IncomingMessage,

     

       
19
       
 
       
  Res extends ServerResponse<Req> = ServerResponse<Req>,

     

       
20
       
-
       
> = (req: Req, res: Res, next: NextFunction) => Promise<void>

     

       
21
       
-
       


     

       
22
       
 
       
/**

     

       
23
       
 
       
 * Wraps a request handler middleware to ensure that `next` is called if it

     

       
24
       
 
       
 * throws or returns a promise that rejects.

     
···

       
26
       
 
       
export function handler<

     

       
27
       
 
       
  Req extends IncomingMessage = IncomingMessage,

     

       
28
       
 
       
  Res extends ServerResponse<Req> = ServerResponse<Req>,

     

       
29
       
-
       
>(fn: Handler<Req, Res> | AsyncHandler<Req, Res>): Handler<Req, Res> {

     

       
30
       
-
       
  return (req, res, next) => {

     

       
31
       
-
       
    // Optimization: NodeJS prefers objects over functions for garbage collection

     

       
32
       
-
       
    const nextSafe = nextOnce.bind({ next })

     

       
33
       
 
       
    try {

     

       
34
       
-
       
      const result = fn(req, res, nextSafe)

     

       
35
       
-
       
      if (result instanceof Promise) result.catch(nextSafe)

     

       
36
       
 
       
    } catch (err) {

     

       
37
       
-
       
      nextSafe(err)

     

       
38
       
 
       
    }

     

       
39
       
-
       
  }

     

       
40
       
-
       


     

       
41
       
-
       
  function nextOnce(this: { next: NextFunction | null }, err?: unknown) {

     

       
42
       
-
       
    const { next } = this

     

       
43
       
-
       
    this.next = null

     

       
44
       
-
       
    next?.(err)

     

       
45
       
 
       
  }

     

       
46
       
 
       
}

     

       
47
       
 
       


     

···

       
9
       
 
       


     

       
10
       
 
       
export type NextFunction = (err?: unknown) => void

     

       
11
       
 
       


     

       
12
       
+
       
export type Middleware<

     

       
13
       
 
       
  Req extends IncomingMessage = IncomingMessage,

     

       
14
       
 
       
  Res extends ServerResponse<Req> = ServerResponse<Req>,

     

       
15
       
 
       
> = (req: Req, res: Res, next: NextFunction) => void

     

       
16
       
 
       


     

       
17
       
+
       
export type Handler<

     

       
18
       
 
       
  Req extends IncomingMessage = IncomingMessage,

     

       
19
       
 
       
  Res extends ServerResponse<Req> = ServerResponse<Req>,

     

       
20
       
+
       
> = (req: Req, res: Res) => unknown | Promise<unknown>

     

       
0
       
 
       

     

       
21
       
 
       
/**

     

       
22
       
 
       
 * Wraps a request handler middleware to ensure that `next` is called if it

     

       
23
       
 
       
 * throws or returns a promise that rejects.

     
···

       
25
       
 
       
export function handler<

     

       
26
       
 
       
  Req extends IncomingMessage = IncomingMessage,

     

       
27
       
 
       
  Res extends ServerResponse<Req> = ServerResponse<Req>,

     

       
28
       
+
       
>(fn: Handler<Req, Res>): Middleware<Req, Res> {

     

       
29
       
+
       
  return async (req, res, next) => {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
30
       
 
       
    try {

     

       
31
       
+
       
      await fn(req, res)

     

       
0
       
 
       

     

       
32
       
 
       
    } catch (err) {

     

       
33
       
+
       
      next(err)

     

       
34
       
 
       
    }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
35
       
 
       
  }

     

       
36
       
 
       
}

     

       
37
       
 
       


     

···

       
4
       
 
       
 * Runs a function with an abort signal that will be triggered when the process

     

       
5
       
 
       
 * receives a termination signal.

     

       
6
       
 
       
 */

     

       
7
       
-
       
export async function run<F extends (signal: AbortSignal) => unknown>(

     

       
8
       
 
       
  fn: F,

     

       
9
       
-
       
): Promise<Awaited<ReturnType<F>>> {

     

       
10
       
 
       
  const killController = new AbortController()

     

       
11
       
 
       


     

       
12
       
 
       
  const abort = (signal?: string) => {

     
···

       
17
       
 
       
  for (const sig of SIGNALS) process.on(sig, abort)

     

       
18
       
 
       


     

       
19
       
 
       
  try {

     

       
20
       
-
       
    return (await fn(killController.signal)) as Awaited<ReturnType<F>>

     

       
21
       
 
       
  } finally {

     

       
22
       
 
       
    abort()

     

       
23
       
 
       
  }

     

···

       
4
       
 
       
 * Runs a function with an abort signal that will be triggered when the process

     

       
5
       
 
       
 * receives a termination signal.

     

       
6
       
 
       
 */

     

       
7
       
+
       
export async function run<F extends (signal: AbortSignal) => Promise<void>>(

     

       
8
       
 
       
  fn: F,

     

       
9
       
+
       
): Promise<void> {

     

       
10
       
 
       
  const killController = new AbortController()

     

       
11
       
 
       


     

       
12
       
 
       
  const abort = (signal?: string) => {

     
···

       
17
       
 
       
  for (const sig of SIGNALS) process.on(sig, abort)

     

       
18
       
 
       


     

       
19
       
 
       
  try {

     

       
20
       
+
       
    await fn(killController.signal)

     

       
21
       
 
       
  } finally {

     

       
22
       
 
       
    abort()

     

       
23
       
 
       
  }

     

···

       
3
       
 
       
import { OAuthResolverError } from '@atproto/oauth-client-node'

     

       
4
       
 
       
import express, { Request, Response } from 'express'

     

       
5
       
 
       
import { getIronSession } from 'iron-session'

     

       
6
       
-
       
import assert from 'node:assert'

     

       
7
       
 
       
import type {

     

       
8
       
 
       
  IncomingMessage,

     

       
9
       
 
       
  RequestListener,

     
···

       
12
       
 
       
import path from 'node:path'

     

       
13
       
 
       


     

       
14
       
 
       
import type { AppContext } from '#/context'

     

       
0
       
 
       

     

       
15
       
 
       
import * as Profile from '#/lexicon/types/app/bsky/actor/profile'

     

       
16
       
 
       
import * as Status from '#/lexicon/types/xyz/statusphere/status'

     

       
17
       
-
       
import { env } from '#/env'

     

       
18
       
 
       
import { handler } from '#/lib/http'

     

       
0
       
 
       

     

       
19
       
 
       
import { page } from '#/lib/view'

     

       
20
       
 
       
import { home, STATUS_OPTIONS } from '#/pages/home'

     

       
21
       
 
       
import { login } from '#/pages/login'

     

       
22
       
-
       
import { ifString } from '#/lib/util'

     

       
23
       
 
       


     

       
24
       
 
       
type Session = { did?: string }

     

       
25
       
 
       


     
···

       
35
       
 
       
  })

     

       
36
       
 
       
  if (!session.did) return null

     

       
37
       
 
       
  try {

     

       
38
       
-
       
    // force rotating the credentials if the request has a no-cache header

     

       
39
       
-
       
    const refresh = req.headers['cache-control']?.includes('no-cache') || 'auto'

     

       
40
       
-
       


     

       
41
       
-
       
    const oauthSession = await ctx.oauthClient.restore(session.did, refresh)

     

       
42
       
 
       
    return oauthSession ? new Agent(oauthSession) : null

     

       
43
       
 
       
  } catch (err) {

     

       
44
       
 
       
    ctx.logger.warn({ err }, 'oauth restore failed')

     
···

       
109
       
 
       
  router.get(

     

       
110
       
 
       
    '/login',

     

       
111
       
 
       
    handler(async (req: Request, res: Response) => {

     

       
112
       
-
       
      res.type('html').send(page(login({})))

     

       
113
       
 
       
    }),

     

       
114
       
 
       
  )

     

       
115
       
 
       


     

       
116
       
 
       
  // Login handler

     

       
117
       
 
       
  router.post(

     

       
118
       
 
       
    '/login',

     

       
119
       
-
       
    express.urlencoded({ extended: true }),

     

       
120
       
 
       
    handler(async (req: Request, res: Response) => {

     

       
121
       
 
       
      const input = ifString(req.body.input)

     

       
122
       
 
       


     

       
123
       
 
       
      // Validate

     

       
124
       
 
       
      if (!input) {

     

       
125
       
-
       
        res.type('html').send(page(login({ error: 'invalid input' })))

     

       
126
       
-
       
        return

     

       
127
       
-
       
      }

     

       
128
       
-
       


     

       
129
       
-
       
      // @NOTE input can be a handle, a DID or a service URL (PDS).

     

       
130
       
-
       


     

       
131
       
-
       
      // Initiate the OAuth flow

     

       
132
       
-
       
      try {

     

       
133
       
-
       
        const url = await ctx.oauthClient.authorize(input, {

     

       
134
       
-
       
          scope: 'atproto transition:generic',

     

       
135
       
-
       
        })

     

       
136
       
-
       
        res.redirect(url.toString())

     

       
137
       
-
       
      } catch (err) {

     

       
138
       
-
       
        ctx.logger.error({ err }, 'oauth authorize failed')

     

       
139
       
-
       


     

       
140
       
-
       
        const error =

     

       
141
       
-
       
          err instanceof OAuthResolverError

     

       
142
       
-
       
            ? err.message

     

       
143
       
-
       
            : "couldn't initiate login"

     

       
144
       
-
       


     

       
145
       
-
       
        res.type('html').send(page(login({ error })))

     

       
146
       
 
       
      }

     

       
147
       
 
       
    }),

     

       
148
       
 
       
  )

     
···

       
228
       
 
       


     

       
229
       
 
       
      if (!agent) {

     

       
230
       
 
       
        // Serve the logged-out view

     

       
231
       
-
       
        res.type('html').send(page(home({ statuses, didHandleMap })))

     

       
232
       
-
       
        return

     

       
233
       
 
       
      }

     

       
234
       
 
       


     

       
235
       
 
       
      // Fetch additional information about the logged-in user

     
···

       
267
       
 
       
  // "Set status" handler

     

       
268
       
 
       
  router.post(

     

       
269
       
 
       
    '/status',

     

       
270
       
-
       
    express.urlencoded({ extended: true }),

     

       
271
       
 
       
    handler(async (req: Request, res: Response) => {

     

       
272
       
 
       
      // If the user is signed in, get an agent which communicates with their server

     

       
273
       
 
       
      const agent = await getSessionAgent(req, res, ctx)

     

       
274
       
 
       
      if (!agent) {

     

       
275
       
-
       
        res.redirect(`/login`)

     

       
276
       
-
       
        return

     

       
277
       
 
       
      }

     

       
278
       
 
       


     

       
279
       
 
       
      const status = ifString(req.body?.status)

     
···

       
290
       
 
       
      }

     

       
291
       
 
       


     

       
292
       
 
       
      if (!Status.validateRecord(record).success) {

     

       
293
       
-
       
        res.status(400).type('html').send('<h1>Error: Invalid status</h1>')

     

       
294
       
-
       
        return

     

       
0
       
 
       

     

       
0
       
 
       

     

       
295
       
 
       
      }

     

       
296
       
 
       


     

       
297
       
 
       
      // Write the status record to the user's repository

     
···

       
307
       
 
       
        uri = res.data.uri

     

       
308
       
 
       
      } catch (err) {

     

       
309
       
 
       
        ctx.logger.warn({ err }, 'failed to write record')

     

       
310
       
-
       
        res

     

       
311
       
 
       
          .status(500)

     

       
312
       
 
       
          .type('html')

     

       
313
       
 
       
          .send('<h1>Error: Failed to write record</h1>')

     

       
314
       
-
       
        return

     

       
315
       
 
       
      }

     

       
316
       
 
       


     

       
317
       
 
       
      try {

     

···

       
3
       
 
       
import { OAuthResolverError } from '@atproto/oauth-client-node'

     

       
4
       
 
       
import express, { Request, Response } from 'express'

     

       
5
       
 
       
import { getIronSession } from 'iron-session'

     

       
0
       
 
       

     

       
6
       
 
       
import type {

     

       
7
       
 
       
  IncomingMessage,

     

       
8
       
 
       
  RequestListener,

     
···

       
11
       
 
       
import path from 'node:path'

     

       
12
       
 
       


     

       
13
       
 
       
import type { AppContext } from '#/context'

     

       
14
       
+
       
import { env } from '#/env'

     

       
15
       
 
       
import * as Profile from '#/lexicon/types/app/bsky/actor/profile'

     

       
16
       
 
       
import * as Status from '#/lexicon/types/xyz/statusphere/status'

     

       
0
       
 
       

     

       
17
       
 
       
import { handler } from '#/lib/http'

     

       
18
       
+
       
import { ifString } from '#/lib/util'

     

       
19
       
 
       
import { page } from '#/lib/view'

     

       
20
       
 
       
import { home, STATUS_OPTIONS } from '#/pages/home'

     

       
21
       
 
       
import { login } from '#/pages/login'

     

       
0
       
 
       

     

       
22
       
 
       


     

       
23
       
 
       
type Session = { did?: string }

     

       
24
       
 
       


     
···

       
34
       
 
       
  })

     

       
35
       
 
       
  if (!session.did) return null

     

       
36
       
 
       
  try {

     

       
37
       
+
       
    const oauthSession = await ctx.oauthClient.restore(session.did)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
38
       
 
       
    return oauthSession ? new Agent(oauthSession) : null

     

       
39
       
 
       
  } catch (err) {

     

       
40
       
 
       
    ctx.logger.warn({ err }, 'oauth restore failed')

     
···

       
105
       
 
       
  router.get(

     

       
106
       
 
       
    '/login',

     

       
107
       
 
       
    handler(async (req: Request, res: Response) => {

     

       
108
       
+
       
      return res.type('html').send(page(login({})))

     

       
109
       
 
       
    }),

     

       
110
       
 
       
  )

     

       
111
       
 
       


     

       
112
       
 
       
  // Login handler

     

       
113
       
 
       
  router.post(

     

       
114
       
 
       
    '/login',

     

       
115
       
+
       
    express.urlencoded(),

     

       
116
       
 
       
    handler(async (req: Request, res: Response) => {

     

       
117
       
 
       
      const input = ifString(req.body.input)

     

       
118
       
 
       


     

       
119
       
 
       
      // Validate

     

       
120
       
 
       
      if (!input) {

     

       
121
       
+
       
        return res.type('html').send(page(login({ error: 'invalid input' })))

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
122
       
 
       
      }

     

       
123
       
 
       
    }),

     

       
124
       
 
       
  )

     
···

       
204
       
 
       


     

       
205
       
 
       
      if (!agent) {

     

       
206
       
 
       
        // Serve the logged-out view

     

       
207
       
+
       
        return res.type('html').send(page(home({ statuses, didHandleMap })))

     

       
0
       
 
       

     

       
208
       
 
       
      }

     

       
209
       
 
       


     

       
210
       
 
       
      // Fetch additional information about the logged-in user

     
···

       
242
       
 
       
  // "Set status" handler

     

       
243
       
 
       
  router.post(

     

       
244
       
 
       
    '/status',

     

       
245
       
+
       
    express.urlencoded(),

     

       
246
       
 
       
    handler(async (req: Request, res: Response) => {

     

       
247
       
 
       
      // If the user is signed in, get an agent which communicates with their server

     

       
248
       
 
       
      const agent = await getSessionAgent(req, res, ctx)

     

       
249
       
 
       
      if (!agent) {

     

       
250
       
+
       
        return res.redirect(`/login`)

     

       
0
       
 
       

     

       
251
       
 
       
      }

     

       
252
       
 
       


     

       
253
       
 
       
      const status = ifString(req.body?.status)

     
···

       
264
       
 
       
      }

     

       
265
       
 
       


     

       
266
       
 
       
      if (!Status.validateRecord(record).success) {

     

       
267
       
+
       
        return res

     

       
268
       
+
       
          .status(400)

     

       
269
       
+
       
          .type('html')

     

       
270
       
+
       
          .send('<h1>Error: Invalid status</h1>')

     

       
271
       
 
       
      }

     

       
272
       
 
       


     

       
273
       
 
       
      // Write the status record to the user's repository

     
···

       
283
       
 
       
        uri = res.data.uri

     

       
284
       
 
       
      } catch (err) {

     

       
285
       
 
       
        ctx.logger.warn({ err }, 'failed to write record')

     

       
286
       
+
       
        return res

     

       
287
       
 
       
          .status(500)

     

       
288
       
 
       
          .type('html')

     

       
289
       
 
       
          .send('<h1>Error: Failed to write record</h1>')

     

       
0
       
 
       

     

       
290
       
 
       
      }

     

       
291
       
 
       


     

       
292
       
 
       
      try {