stuff

flake.nix

···
     supportedSystems = ["x86_64-linux" "aarch64-linux" "aarch64-darwin"];
     forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
     nixpkgsFor = forAllSystems (system:
-      import nixpkgs { inherit system; });
+      import nixpkgs {
+        inherit system;
+        overlays = [self.overlay.default];
+      });
   in {
+    overlay.default = final: prev: let
+      pname = "plonk";
+      version = "0.1.0";
+    in {
+      plonk = with final;
+        buildNpmPackage {
+          inherit pname version;
+          src = ./.;
+          packageJson = ./package.json;
+          buildPhase = "npm run build";
+          npmDepsHash = "sha256-qGCbaFAHd/s9hOTWMjHCam6Kf6pU6IWPybfwYh0sOwc=";
+        };
+    };
+
+    packages = forAllSystems (system: {
+      inherit (nixpkgsFor."${system}") plonk;
+    });
+
+    defaultPackage = forAllSystems (system: nixpkgsFor."${system}".plonk);
 
     devShell = forAllSystems (system: let
       pkgs = nixpkgsFor."${system}";

lexicons/paste.json

···
       "key": "tid",
       "record": {
         "type": "object",
-        "required": ["code", "lang", "title", "createdAt"],
+        "required": [
+          "code",
+          "shortUrl",
+          "lang",
+          "title",
+          "createdAt"
+        ],
         "properties": {
           "code": {
             "type": "string",
···
             "maxGraphemes": 65536,
             "maxLength": 65536
           },
+          "shortUrl": {
+            "type": "string",
+            "minLength": 2,
+            "maxGraphemes": 10,
+            "maxLength": 10
+          },
           "lang": {
             "type": "string",
             "minLength": 1,
···
             "maxGraphemes": 100,
             "maxLength": 100
           },
-          "createdAt": { "type": "string", "format": "datetime" }
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          }
         }
       }
     }

src/db.ts

···
 import SqliteDb from "better-sqlite3";
 import { randomBytes } from "crypto";
+import e from "express";
 
 import {
 	Kysely,
···
 
 export type DatabaseSchema = {
 	paste: Paste;
+	comment: Comment;
 	auth_state: AuthState;
 	auth_session: AuthSession;
 };
···
 export type Paste = {
 	uri: string;
 	authorDid: string;
+	shortUrl: string;
 	code: string;
 	lang: string;
 	title: string;
···
 	state: AuthStateJson;
 };
 
+export type Comment = {
+	uri: string;
+	authorDid: string;
+	body: string;
+	createdAt: string;
+	indexedAt: string;
+	pasteUri: string;
+	pasteCid: string;
+}
+
 type AuthSessionJson = string;
 type AuthStateJson = string;
 
···
 		await db.schema.dropTable("paste").execute();
 	},
 };
+
+migrations["002"] = {
+	async up(db: Kysely<unknown>) {
+		await db.schema
+			.createTable("comment")
+			.addColumn("uri", "varchar", (col) => col.primaryKey())
+			.addColumn("authorDid", "varchar", (col) => col.notNull())
+			.addColumn("body", "varchar", (col) => col.notNull())
+			.addColumn("createdAt", "varchar", (col) => col.notNull())
+			.addColumn("indexedAt", "varchar", (col) => col.notNull())
+			.addColumn("pasteUri", "varchar", (col) => col.notNull())
+			.addColumn("pasteCid", "varchar", (col) => col.notNull())
+			.execute();
+	},
+	async down(db: Kysely<unknown>) {
+		await db.schema.dropTable("comments").execute();
+	},
+}
 
 function generateShortString(length: number): string {
 	return randomBytes(length).toString("base64url").substring(0, length);

src/ingester.ts

···
 import { IdResolver } from "@atproto/identity";
 import { Firehose } from "@atproto/sync";
 import type { Database } from "#/db";
-import { newShortUrl } from "#/db";
 import * as Paste from "#/lexicons/types/ovh/plonk/paste";
+import * as Comment from "#/lexicons/types/ovh/plonk/comment";
 
 export function createIngester(db: Database, idResolver: IdResolver) {
 	const logger = pino({ name: "firehose ingestion" });
···
 					Paste.isRecord(record) &&
 					Paste.validateRecord(record).success
 				) {
-					// Store the status in our SQLite
-					const short_url = await newShortUrl(db);
 					await db
 						.insertInto("paste")
 						.values({
 							uri: evt.uri.toString(),
-							shortUrl,
+							shortUrl: record.shortUrl,
 							authorDid: evt.did,
 							code: record.code,
 							lang: record.lang,
···
 							}),
 						)
 						.execute();
+				} else if (
+					evt.collection === "ovh.plonk.comment" &&
+					Comment.isRecord(record) &&
+					Comment.validateRecord(record).success
+				) {
+					await db
+						.insertInto("comment")
+						.values({
+							uri: evt.uri.toString(),
+							authorDid: evt.did,
+							body: record.content,
+							pasteUri: record.post.uri,
+							pasteCid: record.post.cid,
+							createdAt: record.createdAt,
+							indexedAt: now.toISOString(),
+						})
+						.onConflict((oc) =>
+							oc.column("uri").doUpdateSet({
+								body: record.content,
+								pasteUri: record.post.uri,
+								pasteCid: record.post.cid,
+								indexedAt: now.toISOString(),
+							}),
+						)
+						.execute();
 				}
 			} else if (
 				evt.event === "delete" &&
···
 					.deleteFrom("paste")
 					.where("uri", "=", evt.uri.toString())
 					.execute();
-			}
+			} else if (
+				evt.event === "delete" &&
+				evt.collection === "ovh.plonk.comment"
+			) {
+				// Remove the status from our SQLite
+				await db
+					.deleteFrom("comment")
+					.where("uri", "=", evt.uri.toString())
+					.execute();
+			} 
 		},
 		onError: (err) => {
 			logger.error({ err }, "error on firehose ingestion");

src/lexicons/index.ts

···
   StreamAuthVerifier,
 } from '@atproto/xrpc-server'
 import { schemas } from './lexicons'
+import * as ComAtprotoRepoGetRecord from './types/com/atproto/repo/getRecord'
+import * as ComAtprotoRepoListRecords from './types/com/atproto/repo/listRecords'
 
 export function createServer(options?: XrpcOptions): Server {
   return new Server(options)
···
 export class Server {
   xrpc: XrpcServer
   ovh: OvhNS
-  app: AppNS
   com: ComNS
+  app: AppNS
 
   constructor(options?: XrpcOptions) {
     this.xrpc = createXrpcServer(schemas, options)
     this.ovh = new OvhNS(this)
-    this.app = new AppNS(this)
     this.com = new ComNS(this)
+    this.app = new AppNS(this)
   }
 }
 
···
   }
 }
 
-export class AppNS {
+export class ComNS {
   _server: Server
-  bsky: AppBskyNS
+  atproto: ComAtprotoNS
 
   constructor(server: Server) {
     this._server = server
-    this.bsky = new AppBskyNS(server)
+    this.atproto = new ComAtprotoNS(server)
   }
 }
 
-export class AppBskyNS {
+export class ComAtprotoNS {
   _server: Server
-  actor: AppBskyActorNS
+  repo: ComAtprotoRepoNS
 
   constructor(server: Server) {
     this._server = server
-    this.actor = new AppBskyActorNS(server)
+    this.repo = new ComAtprotoRepoNS(server)
   }
 }
 
-export class AppBskyActorNS {
+export class ComAtprotoRepoNS {
   _server: Server
 
   constructor(server: Server) {
     this._server = server
   }
+
+  getRecord<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoRepoGetRecord.Handler<ExtractAuth<AV>>,
+      ComAtprotoRepoGetRecord.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.repo.getRecord' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  listRecords<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoRepoListRecords.Handler<ExtractAuth<AV>>,
+      ComAtprotoRepoListRecords.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.repo.listRecords' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
 }
 
-export class ComNS {
+export class AppNS {
   _server: Server
-  atproto: ComAtprotoNS
+  bsky: AppBskyNS
 
   constructor(server: Server) {
     this._server = server
-    this.atproto = new ComAtprotoNS(server)
+    this.bsky = new AppBskyNS(server)
   }
 }
 
-export class ComAtprotoNS {
+export class AppBskyNS {
   _server: Server
-  repo: ComAtprotoRepoNS
+  actor: AppBskyActorNS
 
   constructor(server: Server) {
     this._server = server
-    this.repo = new ComAtprotoRepoNS(server)
+    this.actor = new AppBskyActorNS(server)
   }
 }
 
-export class ComAtprotoRepoNS {
+export class AppBskyActorNS {
   _server: Server
 
   constructor(server: Server) {

src/lexicons/lexicons.ts

···
 import { LexiconDoc, Lexicons } from '@atproto/lexicon'
 
 export const schemaDict = {
+  OvhPlonkComment: {
+    lexicon: 1,
+    id: 'ovh.plonk.comment',
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['content', 'createdAt', 'post'],
+          properties: {
+            content: {
+              type: 'string',
+              maxLength: 100000,
+              maxGraphemes: 10000,
+              description: 'comment body',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+              description: 'comment creation timestamp',
+            },
+            post: {
+              type: 'ref',
+              ref: 'lex:com.atproto.repo.strongRef',
+            },
+          },
+        },
+      },
+    },
+  },
   ComAtprotoLabelDefs: {
     lexicon: 1,
     id: 'com.atproto.label.defs',
···
       },
     },
   },
+  ComAtprotoRepoGetRecord: {
+    lexicon: 1,
+    id: 'com.atproto.repo.getRecord',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Get a single record from a repository. Does not require auth.',
+        parameters: {
+          type: 'params',
+          required: ['repo', 'collection', 'rkey'],
+          properties: {
+            repo: {
+              type: 'string',
+              format: 'at-identifier',
+              description: 'The handle or DID of the repo.',
+            },
+            collection: {
+              type: 'string',
+              format: 'nsid',
+              description: 'The NSID of the record collection.',
+            },
+            rkey: {
+              type: 'string',
+              description: 'The Record Key.',
+            },
+            cid: {
+              type: 'string',
+              format: 'cid',
+              description:
+                'The CID of the version of the record. If not specified, then return the most recent version.',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['uri', 'value'],
+            properties: {
+              uri: {
+                type: 'string',
+                format: 'at-uri',
+              },
+              cid: {
+                type: 'string',
+                format: 'cid',
+              },
+              value: {
+                type: 'unknown',
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'RecordNotFound',
+          },
+        ],
+      },
+    },
+  },
+  ComAtprotoRepoListRecords: {
+    lexicon: 1,
+    id: 'com.atproto.repo.listRecords',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'List a range of records in a repository, matching a specific collection. Does not require auth.',
+        parameters: {
+          type: 'params',
+          required: ['repo', 'collection'],
+          properties: {
+            repo: {
+              type: 'string',
+              format: 'at-identifier',
+              description: 'The handle or DID of the repo.',
+            },
+            collection: {
+              type: 'string',
+              format: 'nsid',
+              description: 'The NSID of the record type.',
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+              description: 'The number of records to return.',
+            },
+            cursor: {
+              type: 'string',
+            },
+            rkeyStart: {
+              type: 'string',
+              description:
+                'DEPRECATED: The lowest sort-ordered rkey to start from (exclusive)',
+            },
+            rkeyEnd: {
+              type: 'string',
+              description:
+                'DEPRECATED: The highest sort-ordered rkey to stop at (exclusive)',
+            },
+            reverse: {
+              type: 'boolean',
+              description: 'Flag to reverse the order of the returned records.',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['records'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              records: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:com.atproto.repo.listRecords#record',
+                },
+              },
+            },
+          },
+        },
+      },
+      record: {
+        type: 'object',
+        required: ['uri', 'cid', 'value'],
+        properties: {
+          uri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          cid: {
+            type: 'string',
+            format: 'cid',
+          },
+          value: {
+            type: 'unknown',
+          },
+        },
+      },
+    },
+  },
   OvhPlonkPaste: {
     lexicon: 1,
     id: 'ovh.plonk.paste',
···
         key: 'tid',
         record: {
           type: 'object',
-          required: ['code', 'lang', 'title', 'createdAt'],
+          required: ['code', 'shortUrl', 'lang', 'title', 'createdAt'],
           properties: {
             code: {
               type: 'string',
               minLength: 1,
               maxGraphemes: 65536,
               maxLength: 65536,
+            },
+            shortUrl: {
+              type: 'string',
+              minLength: 2,
+              maxGraphemes: 10,
+              maxLength: 10,
             },
             lang: {
               type: 'string',
···
 export const schemas: LexiconDoc[] = Object.values(schemaDict) as LexiconDoc[]
 export const lexicons: Lexicons = new Lexicons(schemas)
 export const ids = {
+  OvhPlonkComment: 'ovh.plonk.comment',
   ComAtprotoLabelDefs: 'com.atproto.label.defs',
+  ComAtprotoRepoGetRecord: 'com.atproto.repo.getRecord',
+  ComAtprotoRepoListRecords: 'com.atproto.repo.listRecords',
   OvhPlonkPaste: 'ovh.plonk.paste',
   AppBskyActorProfile: 'app.bsky.actor.profile',
   ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',

src/lexicons/types/com/atproto/repo/getRecord.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+export interface QueryParams {
+  /** The handle or DID of the repo. */
+  repo: string
+  /** The NSID of the record collection. */
+  collection: string
+  /** The Record Key. */
+  rkey: string
+  /** The CID of the version of the record. If not specified, then return the most recent version. */
+  cid?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  uri: string
+  cid?: string
+  value: {}
+  [k: string]: unknown
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'RecordNotFound'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicons/types/com/atproto/repo/listRecords.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+export interface QueryParams {
+  /** The handle or DID of the repo. */
+  repo: string
+  /** The NSID of the record type. */
+  collection: string
+  /** The number of records to return. */
+  limit: number
+  cursor?: string
+  /** DEPRECATED: The lowest sort-ordered rkey to start from (exclusive) */
+  rkeyStart?: string
+  /** DEPRECATED: The highest sort-ordered rkey to stop at (exclusive) */
+  rkeyEnd?: string
+  /** Flag to reverse the order of the returned records. */
+  reverse?: boolean
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  records: Record[]
+  [k: string]: unknown
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput
+
+export interface Record {
+  uri: string
+  cid: string
+  value: {}
+  [k: string]: unknown
+}
+
+export function isRecord(v: unknown): v is Record {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'com.atproto.repo.listRecords#record'
+  )
+}
+
+export function validateRecord(v: unknown): ValidationResult {
+  return lexicons.validate('com.atproto.repo.listRecords#record', v)
+}

src/lexicons/types/ovh/plonk/comment.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../lexicons'
+import { isObj, hasProp } from '../../../util'
+import { CID } from 'multiformats/cid'
+import * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef'
+
+export interface Record {
+  /** comment body */
+  content: string
+  /** comment creation timestamp */
+  createdAt: string
+  post: ComAtprotoRepoStrongRef.Main
+  [k: string]: unknown
+}
+
+export function isRecord(v: unknown): v is Record {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    (v.$type === 'ovh.plonk.comment#main' || v.$type === 'ovh.plonk.comment')
+  )
+}
+
+export function validateRecord(v: unknown): ValidationResult {
+  return lexicons.validate('ovh.plonk.comment#main', v)
+}

src/lexicons/types/ovh/plonk/paste.ts

···
 
 export interface Record {
   code: string
+  shortUrl: string
   lang: string
   title: string
   createdAt: string

src/mixins/post.pug

···
-mixin post(paste, didHandleMap)
+mixin post(paste, handle, did)
   div.post
     p
       a(href=`/p/${paste.shortUrl}`)
         | #{paste.title}
       p.post-info
         | by 
-        a(href=`/u/${encodeURIComponent(paste.authorDid)}`)
-          | @#{didHandleMap[paste.authorDid]}
+        a(href=`/u/${did}`)
+          | @#{handle}
         |  ·
         | #{timeDifference(now, Date.parse(paste.createdAt))} ago
         | ·

src/public/styles.css

···
   align-self: flex-end;
 }
 
-.timeline {
+.timeline, .comments {
   display: flex;
   flex-direction: column;
   gap: 1rem;

src/routes.ts

···
 import { Agent } from "@atproto/api";
 import { getPds, DidResolver } from "@atproto/identity";
 import { TID } from "@atproto/common";
+import { Agent } from "@atproto/api";
 import { newShortUrl } from "#/db";
 
 import * as Paste from "#/lexicons/types/ovh/plonk/paste";
+import * as Comment from "#/lexicons/types/ovh/plonk/comment";
+import { ComAtprotoRepoNS } from "#/lexicons";
 
 type Session = {
 	did: string;
···
 
 		// Map user DIDs to their domain-name handles
 		const didHandleMap = await ctx.resolver.resolveDidsToHandles(
-			pastes.map((s) => s.authorDid),
+			pastes.map((s) => s.authorDid).concat(agent? [agent.assertDid]:[]),
 		);
 
 		if (!agent) {
···
 
 	router.get("/u/:authorDid", async (req, res) => {
 		const { authorDid } = req.params;
-		const pastes = await ctx.db
-			.selectFrom("paste")
-			.selectAll()
-			.where("authorDid", "=", authorDid)
-			.orderBy("indexedAt", "desc")
-			.execute();
+		const resolver = new DidResolver({});
+		const didDocument = await resolver.resolve(authorDid);
+		if (!didDocument) {
+			return res.status(404);
+		}
+		const pds = getPds(didDocument);
+		if (!pds) {
+			return res.status(404);
+		}
+		const agent = new Agent(pds);
+		const response = await agent.com.atproto.repo.listRecords({
+			repo: authorDid,
+			collection: 'ovh.plonk.paste',
+			limit: 99,
+		});
+		const pastes = response.data.records;
 		let didHandleMap = {};
 		didHandleMap[authorDid] = await ctx.resolver.resolveDidToHandle(authorDid);
 		return res.render("user", { pastes, authorDid, didHandleMap });
···
 		if (!ret) {
 			return res.status(404);
 		}
+		var comments = await ctx.db
+			.selectFrom("comment")
+			.selectAll()
+			.where("pasteUri", '=', ret.uri)
+			.execute();
 		const { authorDid: did, uri } = ret;
-		const handle = await ctx.resolver.resolveDidToHandle(did);
+		const didHandleMap = await ctx.resolver.resolveDidsToHandles(
+			comments.map((c) => c.authorDid).concat([did]),
+		)
 		const resolver = new DidResolver({});
 		const didDocument = await resolver.resolve(did);
 		if (!didDocument) {
···
 		if (!pds) {
 			return res.status(404);
 		}
+		const agent = new Agent(pds);
 		const aturi = new AtUri(uri);
-		const url = new URL(`${pds}/xrpc/com.atproto.repo.getRecord`);
-		url.searchParams.set("repo", aturi.hostname);
-		url.searchParams.set("collection", aturi.collection);
-		url.searchParams.set("rkey", aturi.rkey);
-
-		const response = await fetch(url.toString());
-
-		if (!response.ok) {
-			return res.status(404);
-		}
+		const response = await agent.com.atproto.repo.getRecord({
+			repo: aturi.hostname,
+			collection: aturi.collection,
+			rkey: aturi.rkey
+		});
 
-		const pasteRecord = await response.json();
 		const paste =
-			Paste.isRecord(pasteRecord.value) &&
-			Paste.validateRecord(pasteRecord.value).success
-				? pasteRecord.value
+			Paste.isRecord(response.data.value) &&
+			Paste.validateRecord(response.data.value).success
+				? response.data.value
 				: {};
 
-		return res.render("paste", { paste, handle, shortUrl });
+		return res.render("paste", { paste, authorDid: did, uri: response.data.uri, didHandleMap, shortUrl, comments });
 	});
 
+	router.get("/p/:shortUrl/raw", async (req, res) => {
+		res.redirect(`/r/${req.params.shortUrl}`)
+	});
 	router.get("/r/:shortUrl", async (req, res) => {
 		const { shortUrl } = req.params;
 		const ret = await ctx.db
···
 		return res.send(ret.code);
 	});
 
+	router.get("/reset", async (req, res) => {
+		const agent = await getSessionAgent(req, res, ctx);
+		if (!agent) {
+			return res.redirect('/');
+		}
+		const response = await agent.com.atproto.repo.listRecords({
+			repo: agent.assertDid,
+			collection: 'ovh.plonk.paste',
+			limit: 10,
+		});
+		const vals = response.data.records;
+		for (const v of vals) {
+			const aturl = new AtUri(v.uri);
+			await agent.com.atproto.repo.deleteRecord({
+				repo: agent.assertDid,
+				collection: aturl.collection,
+				rkey: aturl.rkey,
+			});
+		}
+		return res.redirect('/');
+	});
+
 	router.post("/paste", async (req, res) => {
 		const agent = await getSessionAgent(req, res, ctx);
 		if (!agent) {
···
 		}
 
 		const rkey = TID.nextStr();
+		const shortUrl = await newShortUrl(ctx.db);
 		const record = {
 			$type: "ovh.plonk.paste",
 			code: req.body?.code,
 			lang: req.body?.lang,
+			shortUrl,
 			title: req.body?.title,
 			createdAt: new Date().toISOString(),
 		};
···
 				.execute();
 			ctx.logger.info(res, "wrote back to db");
 			return res.redirect(`/p/${shortUrl}`);
+		} catch (err) {
+			ctx.logger.warn(
+				{ err },
+				"failed to update computed view; ignoring as it should be caught by the firehose",
+			);
+		}
+
+		return res.redirect("/");
+	});
+
+	router.post("/:paste/comment", async (req, res) => {
+		const agent = await getSessionAgent(req, res, ctx);
+
+		if (!agent) {
+			return res
+				.status(401)
+				.type("html")
+				.send("<h1>Error: Session required</h1>");
+		}
+		
+		const pasteUri = req.params.paste;
+		const aturi = new AtUri(pasteUri);
+		const pasteResponse = await agent.com.atproto.repo.getRecord({
+			repo: aturi.hostname,
+			collection: aturi.collection,
+			rkey: aturi.rkey
+		});
+		const pasteCid = pasteResponse.data.cid;
+		if (!pasteCid) {
+			return res
+				.status(401)
+				.type("html")
+				.send("invalid paste");
+		}
+
+		const rkey = TID.nextStr();
+		const record = {
+			$type: "ovh.plonk.comment",
+			content: req.body?.comment,
+			post: {
+				uri: pasteUri,
+				cid: pasteCid
+			},
+			createdAt: new Date().toISOString(),
+		};
+
+		if (!Comment.validateRecord(record).success) {
+			return res
+				.status(400)
+				.type("html")
+				.send("<h1>Error: Invalid status</h1>");
+		}
+
+		let uri;
+		try {
+			const res = await agent.com.atproto.repo.putRecord({
+				repo: agent.assertDid,
+				collection: "ovh.plonk.comment",
+				rkey,
+				record,
+				validate: false,
+			});
+			uri = res.data.uri;
+		} catch (err) {
+			ctx.logger.warn({ err }, "failed to put record");
+			return res
+				.status(500)
+				.type("html")
+				.send("<h3>Error: Failed to write record</h1>");
+		}
+
+		try {
+			await ctx.db
+				.insertInto("comment")
+				.values({
+					uri,
+					body: record.content,
+					authorDid: agent.assertDid,
+					pasteUri: record.post.uri,
+					pasteCid: record.post.cid,
+					createdAt: record.createdAt,
+					indexedAt: new Date().toISOString(),
+				})
+				.execute();
+			ctx.logger.info(res, "wrote back to db");
+			const originalPaste = await ctx.db.selectFrom('paste').selectAll().where('uri', '=', pasteUri).executeTakeFirst();
+			return res.redirect(`/p/${originalPaste.shortUrl}#${encodeURIComponent(uri)}`);
 		} catch (err) {
 			ctx.logger.warn(
 				{ err },

src/views/index.pug

···
 
       div.timeline
         each paste in pastes
-          +post(paste, didHandleMap)
+          - var handle = didHandleMap[paste.authorDid]
+          +post(paste, handle, paste.authorDid)

src/views/paste.pug

···
     main#content
       h1 #{paste.title}
       p 
-        | by @#{handle} ·
+        | by @#{didHandleMap[authorDid]} ·
         | #{timeDifference(now, Date.parse(paste.createdAt))} ago ·
         | #{paste.lang} · 
         | #{paste.code.split('\n').length} loc · 
         a(href=`/r/${shortUrl}`) raw
       pre
         | #{paste.code}
+      hr
+
+      div.comments
+        each comment in comments
+          div.comment(id=`${encodeURIComponent(comment.uri)}`)
+            p 
+              | by @#{didHandleMap[comment.authorDid]} ·
+              | #{timeDifference(now, Date.parse(paste.createdAt))} ago
+            p 
+              | #{comment.body}
+      hr
+
+      form(action=`/${encodeURIComponent(uri)}/comment` method="post").post-form
+        div.post-row
+          textarea#code(name="comment" rows="5" placeholder="add a comment" required).post-input-code
+
+        div.post-submit-row
+          button(type="submit").post-input-submit zonk!

src/views/user.pug

···
       h1 plonks by @#{handle}
       div.timeline
         each paste in pastes
-          +post(paste, didHandleMap)
+          +post(paste.value, handle, authorDid)

tsup.config.ts

···
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  outDir: 'dist',
+  clean: true,
+  format: 'esm',
+  target: 'node18',
+  dts: true,
+  minify: true,
+  sourcemap: true,
+});