diff --git a/.dockerignore b/.dockerignore
index c627bb6c..5c8d6f5b 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -14,4 +14,6 @@ helm-charts
 .idea
 coverage*
 uploads
-logs
\ No newline at end of file
+logs
+dist
+pages/dist
\ No newline at end of file
diff --git a/.github/workflows/docker-publish.yml b/.github/workflows/docker-publish.yml
index fc8026cc..21377659 100644
--- a/.github/workflows/docker-publish.yml
+++ b/.github/workflows/docker-publish.yml
@@ -71,7 +71,7 @@ jobs:
             # https://github.com/docker/build-push-action
             - name: Build and push Docker image
               id: build-and-push
-              uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # v5.0.0
+              uses: docker/build-push-action@v5.1.0
               with:
                   context: .
                   push: ${{ github.event_name != 'pull_request' }}
diff --git a/.gitignore b/.gitignore
index db1bd149..38109eac 100644
--- a/.gitignore
+++ b/.gitignore
@@ -168,4 +168,8 @@ dist
 .yarn/install-state.gz
 .pnp.\*
 config/config.toml
-uploads/
\ No newline at end of file
+config/config.internal.toml
+uploads/
+pages/dist
+log.txt
+*.log
\ No newline at end of file
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 00000000..980184cd
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,18 @@
+{
+    "configurations": [
+        {
+            "type": "node",
+            "name": "vscode-jest-tests.v2.lysand",
+            "request": "launch",
+            "args": [
+                "test",
+                "${jest.testFile}"
+            ],
+            "cwd": "/home/jessew/Dev/lysand",
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen",
+            "disableOptimisticBPs": true,
+            "program": "/home/jessew/.bun/bin/bun"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 00000000..6286bcf3
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,5 @@
+{
+	"typescript.tsdk": "node_modules/typescript/lib",
+	"jest.jestCommandLine": "/home/jessew/.bun/bin/bun test",
+	"jest.rootPath": "."
+}
diff --git a/API.md b/API.md
new file mode 100644
index 00000000..7d44dec9
--- /dev/null
+++ b/API.md
@@ -0,0 +1,268 @@
+# API
+
+The Lysand project uses the Mastodon API to interact with clients. However, the moderation API is custom-made for Lysand Server, as it allows for more fine-grained control over the server's behavior.
+
+## Flags, ModTags and ModNotes
+
+Flags are used by Lysand Server to automatically attribute tags to a status or account based on rules. ModTags and ModNotes are used by moderators to manually tag and take notes on statuses and accounts.
+
+The difference between flags and modtags is that flags are automatically attributed by the server, while modtags are manually attributed by moderators.
+
+### Flag Types
+
+- `content_filter`: (Statuses only) The status contains content that was filtered by the server's content filter.
+- `bio_filter`: (Accounts only) The account's bio contains content that was filtered by the server's content filter.
+- `emoji_filter`: The status or account contains an emoji that was filtered by the server's content filter.
+- `reported`: The status or account was previously reported by a user.
+- `suspended`: The status or account was previously suspended by a moderator.
+- `silenced`: The status or account was previously silenced by a moderator.
+
+### ModTag Types
+
+ModTag do not have set types and can be anything. Lysand Server autosuggest previously used tags when a moderator is adding a new tag to avoid duplicates.
+
+### Data Format
+
+```ts
+type Flag = {
+  id: string,
+  // One of the following two fields will be present
+  flaggedStatus?: Status,
+  flaggedUser?: User,
+  flagType: string,
+  createdAt: string,
+}
+
+type ModTag = {
+  id: string,
+  // One of the following two fields will be present
+  taggedStatus?: Status,
+  taggedUser?: User,
+  mod: User,
+  tag: string,
+  createdAt: string,
+}
+
+type ModNote = {
+  id: string,
+  // One of the following two fields will be present
+  notedStatus?: Status,
+  notedUser?: User,
+  mod: User,
+  note: string,
+  createdAt: string,
+}
+```
+
+The `User` and `Status` types are the same as the ones in the Mastodon API.
+
+## Moderation API Routes
+
+### `GET /api/v1/moderation/accounts/:id`
+
+Returns full moderation data and flags for the account with the given ID.
+
+Output format:
+
+```ts
+{
+  id: string, // Same ID as in account field
+  flags: Flag[],
+  modtags: ModTag[],
+  modnotes: ModNote[],
+  account: User,
+}
+```
+
+### `GET /api/v1/moderation/statuses/:id`
+
+Returns full moderation data and flags for the status with the given ID.
+
+Output format:
+
+```ts
+{
+  id: string, // Same ID as in status field
+  flags: Flag[],
+  modtags: ModTag[],
+  modnotes: ModNote[],
+  status: Status,
+}
+```
+
+### `POST /api/v1/moderation/accounts/:id/modtags`
+
+Params:
+- `tag`: string
+
+Adds a modtag to the account with the given ID
+
+### `POST /api/v1/moderation/statuses/:id/modtags`
+
+Params:
+- `tag`: string
+
+Adds a modtag to the status with the given ID
+
+### `POST /api/v1/moderation/accounts/:id/modnotes`
+
+Params:
+- `note`: string
+
+Adds a modnote to the account with the given ID
+
+### `POST /api/v1/moderation/statuses/:id/modnotes`
+
+Params:
+- `note`: string
+
+Adds a modnote to the status with the given ID
+
+### `DELETE /api/v1/moderation/accounts/:id/modtags/:modtag_id`
+
+Deletes the modtag with the given ID from the account with the given ID
+
+### `DELETE /api/v1/moderation/statuses/:id/modtags/:modtag_id`
+
+Deletes the modtag with the given ID from the status with the given ID
+
+### `DELETE /api/v1/moderation/accounts/:id/modnotes/:modnote_id`
+
+Deletes the modnote with the given ID from the account with the given ID
+
+### `DELETE /api/v1/moderation/statuses/:id/modnotes/:modnote_id`
+
+Deletes the modnote with the given ID from the status with the given ID
+
+### `GET /api/v1/moderation/modtags`
+
+Returns a list of all modtags previously used by moderators
+
+Output format:
+
+```ts
+{
+  tags: string[],
+}
+```
+
+### `GET /api/v1/moderation/accounts/flags/search`
+
+Allows moderators to search for accounts based on their flags, this can also include status flags
+
+Params:
+- `limit`: Number
+- `min_id`: String. Returns results immediately newer than this ID. In effect, sets a cursor at this ID and paginates forward.
+- `max_id`: String. All results returned will be lesser than this ID. In effect, sets an upper bound on results.
+- `since_id`: String. All results returned will be greater than this ID. In effect, sets a lower bound on results.
+- `flags`: String (optional). Comma-separated list of flag types to filter by. Can be left out to return accounts with at least one flag
+- `flag_count`: Number (optional). Minimum number of flags to filter by
+- `include_statuses`: Boolean (optional). If true, includes status flags in the search results
+- `account_id`: Array of strings (optional). Filters accounts by account ID
+
+This method returns a `Link` header the same way Mastodon does, to allow for pagination.
+
+Output format:
+
+```ts
+{
+  accounts: {
+    account: User,
+    modnotes: ModNote[],
+    flags: Flag[],
+    statuses?: {
+        status: Status,
+        modnotes: ModNote[],
+        flags: Flag[],
+    }[],
+  }[],
+}
+```
+
+### `GET /api/v1/moderation/statuses/flags/search`
+
+Allows moderators to search for statuses based on their flags
+
+Params:
+- `limit`: Number
+- `min_id`: String. Returns results immediately newer than this ID. In effect, sets a cursor at this ID and paginates forward.
+- `max_id`: String. All results returned will be lesser than this ID. In effect, sets an upper bound on results.
+- `since_id`: String. All results returned will be greater than this ID. In effect, sets a lower bound on results.
+- `flags`: String (optional). Comma-separated list of flag types to filter by. Can be left out to return statuses with at least one flag
+- `flag_count`: Number (optional). Minimum number of flags to filter by
+- `account_id`: Array of strings (optional). Filters statuses by account ID
+
+This method returns a `Link` header the same way Mastodon does, to allow for pagination.
+
+Output format:
+
+```ts
+{
+  statuses: {
+    status: Status,
+    modnotes: ModNote[],
+    flags: Flag[],
+  }[],
+}
+```
+
+### `GET /api/v1/moderation/accounts/modtags/search`
+
+Allows moderators to search for accounts based on their modtags
+
+Params:
+- `limit`: Number
+- `min_id`: String. Returns results immediately newer than this ID. In effect, sets a cursor at this ID and paginates forward.
+- `max_id`: String. All results returned will be lesser than this ID. In effect, sets an upper bound on results.
+- `since_id`: String. All results returned will be greater than this ID. In effect, sets a lower bound on results.
+- `tags`: String (optional). Comma-separated list of tags to filter by. Can be left out to return accounts with at least one tag
+- `tag_count`: Number (optional). Minimum number of tags to filter by
+- `include_statuses`: Boolean (optional). If true, includes status tags in the search results
+- `account_id`: Array of strings (optional). Filters accounts by account ID
+
+This method returns a `Link` header the same way Mastodon does, to allow for pagination.
+
+Output format:
+
+```ts
+{
+  accounts: {
+    account: User,
+    modnotes: ModNote[],
+    modtags: ModTag[],
+    statuses?: {
+        status: Status,
+        modnotes: ModNote[],
+        modtags: ModTag[],
+    }[],
+  }[],
+}
+```
+
+### `GET /api/v1/moderation/statuses/modtags/search`
+
+Allows moderators to search for statuses based on their modtags
+
+Params:
+- `limit`: Number
+- `min_id`: String. Returns results immediately newer than this ID. In effect, sets a cursor at this ID and paginates forward.
+- `max_id`: String. All results returned will be lesser than this ID. In effect, sets an upper bound on results.
+- `since_id`: String. All results returned will be greater than this ID. In effect, sets a lower bound on results.
+- `tags`: String (optional). Comma-separated list of tags to filter by. Can be left out to return statuses with at least one tag
+- `tag_count`: Number (optional). Minimum number of tags to filter by
+- `account_id`: Array of strings (optional). Filters statuses by account ID
+- `include_statuses`: Boolean (optional). If true, includes status tags in the search results
+
+This method returns a `Link` header the same way Mastodon does, to allow for pagination.
+
+Output format:
+
+```ts
+{
+  statuses: {
+    status: Status,
+    modnotes: ModNote[],
+    modtags: ModTag[],
+  }[],
+}
+```
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 19e9ce47..bfef0cf7 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,5 +1,6 @@
 # Contributing to Lysand
 
+> [!NOTE]
 > This document was authored by [@CPlusPatch](https://github.com/CPlusPatch).
 
 Thank you for your interest in contributing to Lysand! We welcome contributions from everyone, regardless of their level of experience or expertise.
@@ -8,7 +9,7 @@ Thank you for your interest in contributing to Lysand! We welcome contributions
 
 Lysand is built using the following technologies:
 
-- [Bun](https://bun.sh) - A JavaScript runtime similar to Node.js, but improved
+- [Bun](https://bun.sh) - A JavaScript runtime similar to Node.js, but faster and with more features
 - [PostgreSQL](https://www.postgresql.org/) - A relational database
   - [`pg_uuidv7`](https://github.com/fboulnois/pg_uuidv7) - A PostgreSQL extension that provides a UUIDv7 data type
 - [UnoCSS](https://unocss.dev) - A utility-first CSS framework, used for the login page
@@ -67,7 +68,10 @@ RUN chmod +x /docker-entrypoint-initdb.d/init.sh
 ```
 
 4. Copy the `config.toml.example` file to `config.toml` and fill in the values (you can leave most things to the default, but you will need to configure things such as the database connection)
-   
+
+> [!WARNING]
+> You should disable Prisma Redis caching while developing, as it can mess up tests
+
 5. Generate the Prisma client:
 
 ```bash
@@ -89,6 +93,15 @@ bun dev
 
 If your port number is lower than 1024, you may need to run the command as root.
 
+### Running the Vite server
+
+To start the Vite server, run:
+```sh
+bun vite:dev
+```
+
+This should be run in a separate terminal window. The Vite server is used to serve the frontend assets and to provide hot module reloading.
+
 ## Running tests
 
 To run the tests, run:
@@ -96,7 +109,7 @@ To run the tests, run:
 bun test
 ```
 
-The tests are located in the `tests/` directory and follow a Jest-like syntax. The server must be started with `bun dev` before running the tests.
+The tests are located in the `tests/` directory and follow a Jest-like syntax. The server does not need to be started before running the tests, as the tests will spawn their own Lysand server instance.
 
 ## Code style
 
diff --git a/Dockerfile b/Dockerfile
index edb38027..51b9eb58 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,31 +1,36 @@
 # use the official Bun image
 # see all versions at https://hub.docker.com/r/oven/bun/tags
-FROM oven/bun:1.0.14-alpine as base
+FROM oven/bun:1.0.30-alpine as base
 WORKDIR /usr/src/app
 
-RUN apk add vips-dev
 # Required for Prisma to work
-COPY --from=node:18-alpine /usr/local/bin/node /usr/local/bin/node
+# COPY --from=node:18-alpine /usr/local/bin/node /usr/local/bin/node
 
 # install dependencies into temp directory
 # this will cache them and speed up future builds
 FROM base AS install
-RUN mkdir -p /temp/dev
-COPY package.json bun.lockb /temp/dev/
-RUN cd /temp/dev && bun install --frozen-lockfile
 
 # install with --production (exclude devDependencies)
-RUN mkdir -p /temp/prod
-COPY package.json bun.lockb /temp/prod/
-RUN cd /temp/prod && bun install --frozen-lockfile --production.
+RUN mkdir -p /temp
+COPY . /temp
+WORKDIR /temp
+RUN bun install --frozen-lockfile --production
+
+# Build Vite in pages
+RUN bunx --bun vite build pages
+
+# Build the project
+RUN bun run build.ts
+WORKDIR /temp/dist
 
 # copy production dependencies and source code into final image
 FROM base AS release
 
 # Create app directory
 RUN mkdir -p /app
-COPY --from=install /temp/prod/node_modules /app/node_modules
-COPY . /app
+COPY --from=install /temp/dist /app/dist
+COPY entrypoint.sh /app
+
 
 LABEL org.opencontainers.image.authors "Gaspard Wierzbinski (https://cpluspatch.dev)"
 LABEL org.opencontainers.image.source "https://github.com/lysand-org/lysand"
@@ -34,11 +39,8 @@ LABEL org.opencontainers.image.licenses "AGPL-3.0"
 LABEL org.opencontainers.image.title "Lysand Server"
 LABEL org.opencontainers.image.description "Lysand Server docker image"
 
-# CD to app
-WORKDIR /app
-RUN bunx prisma generate
 # CD to app
 WORKDIR /app
 ENV NODE_ENV=production
 # Run migrations and start the server
-ENTRYPOINT [ "bun", "migrate", "&&", "bun", "run", "index.ts" ]
+ENTRYPOINT [ "./entrypoint.sh" "start" ]
diff --git a/README.md b/README.md
index b23635cf..83a9e54d 100644
--- a/README.md
+++ b/README.md
@@ -4,14 +4,14 @@
 
 ![Postgres](https://img.shields.io/badge/postgres-%23316192.svg?style=for-the-badge&logo=postgresql&logoColor=white) ![Bun](https://img.shields.io/badge/Bun-%23000000.svg?style=for-the-badge&logo=bun&logoColor=white) ![VS Code Insiders](https://img.shields.io/badge/VS%20Code%20Insiders-35b393.svg?style=for-the-badge&logo=visual-studio-code&logoColor=white) ![TypeScript](https://img.shields.io/badge/typescript-%23007ACC.svg?style=for-the-badge&logo=typescript&logoColor=white) ![Linux](https://img.shields.io/badge/Linux-FCC624?style=for-the-badge&logo=linux&logoColor=black) ![Docker](https://img.shields.io/badge/docker-%230db7ed.svg?style=for-the-badge&logo=docker&logoColor=white) ![ESLint](https://img.shields.io/badge/ESLint-4B3263?style=for-the-badge&logo=eslint&logoColor=white) [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa?style=for-the-badge)](code_of_conduct.md)
 
-
 ## What is this?
 
-This is a project to create a federated social network based on the [Lysand](https://lysand.org) protocol. It is currently in alpha phase, with basic federation and API support.
+This is a project to create a federated social network based on the [Lysand](https://lysand.org) protocol. It is currently in alpha phase, with basic federation and almost complete Mastodon API support.
 
-This project aims to be a fully featured social network, with a focus on privacy, security, and performance. It will implement the Mastodon API for support with clients that already support Mastodon or Pleroma.
+This project aims to be a fully featured social network, with a focus on privacy, security, and performance. It implements the Mastodon API for support with clients that already support Mastodon or Pleroma.
 
-> **Note:** This project is not affiliated with Mastodon or Pleroma, and is not a fork of either project. It is a new project built from the ground up.
+> [!NOTE]  
+> This project is not affiliated with Mastodon or Pleroma, and is not a fork of either project. It is a new project built from the ground up.
 
 ## Features
 
@@ -31,7 +31,8 @@ This project aims to be a fully featured social network, with a focus on privacy
 
 ## Benchmarks
 
-> **Note**: These benchmarks are not representative of real-world performance, and are only meant to be used as a rough guide.
+> [!NOTE]
+> These benchmarks are not representative of real-world performance, and are only meant to be used as a rough guide. Load, and therefore performance, will vary depending on the server's hardware and software configuration, as well as user activity.
 
 ### Timeline Benchmarks
 
@@ -63,17 +64,21 @@ $ bun run benchmarks/timelines.ts 10000
 ✓ 10000 requests fulfilled in 12.44852s
 ```
 
-Lysand is extremely fast and can handle tens of thousands of HTTP requests per second on a good server.
+Lysand is extremely fast and can handle thousands of HTTP requests per second on a good server.
 
 ## How do I run it?
 
 ### Requirements
 
-- The [Bun Runtime](https://bun.sh), version 1.0.5 or later (usage of the latest version is recommended)
+- The [Bun Runtime](https://bun.sh), version 1.0.30 or later (usage of the latest version is recommended)
 - A PostgreSQL database
 - (Optional but recommended) A Linux-based operating system
+- (Optional if you want search) A working Meiliseach instance
 
-> **Note**: We will not be offerring support to Windows or MacOS users. If you are using one of these operating systems, please use a virtual machine or container to run Lysand.
+> [!WARNING]
+> Lysand has not been tested on Windows or MacOS. It is recommended to use a Linux-based operating system to run Lysand.
+> 
+> We will not be offerring support to Windows or MacOS users. If you are using one of these operating systems, please use a virtual machine or container to run Lysand.
 
 ### Installation
 
@@ -125,6 +130,18 @@ RUN chmod +x /docker-entrypoint-initdb.d/init.sh
 bun migrate
 ```
 
+6. (If you want search)
+Create a Meilisearch instance (using Docker is recommended). For a [`docker-compose`] file, copy the `meilisearch` service from the [`docker-compose.yml`](docker-compose.yml) file.
+
+Set up Meiliseach's API key by passing the `MEILI_MASTER_KEY` environment variable to the server. Then, enale and configure search in the config file.
+7. Build everything:
+
+```bash
+bun prod-build
+```
+
+You may now start the server with `bun start`. It lives in the `dist/` directory, all the other code can be removed from this point onwards.
+In fact, the `bun start` script merely runs `bun run dist/index.js --prod`!
 ### Running
 
 To run the server, simply run the following command:
@@ -138,24 +155,31 @@ bun start
 Lysand includes a built-in CLI for managing the server. To use it, simply run the following command:
 
 ```bash
-bun cli
+bun cli help
 ```
 
-You can use the `help` command to see a list of available commands. These include creating users, deleting users and more.
+If you are running a production build, you will need to run `bun run dist/cli.js` or `./entrypoint.sh cli` instead.
+
+You can use the `help` command to see a list of available commands. These include creating users, deleting users and more. Each command also has a `--help,-h` flag that you can use to see more information about the command.
 
 #### Scripting with the CLI
 
-Some CLI commands that return data as tables can be used in scripts. To do so, you can use the `--json` flag to output the data as JSON instead of a table, or even `--csv` to output the data as CSV. See `bun cli help` for more information.
+Some CLI commands that return data as tables can be used in scripts. To convert them to JSON or CSV, some commands allow you to specify a `--format` flag that can be either `"json"` or `"csv"`. See `bun cli help` or `bun cli <command> -h` for more information.
 
 Flags can be used in any order and anywhere in the script (except for the `bun cli` command itself). The command arguments themselves must be in the correct order, however.
 
+### Rebuilding the Search Index
+
+You may use the `bun cli index rebuild` command to automatically push all posts and users to Meilisearch, if it is configured. This is useful if you have just set up Meilisearch, or if you accidentally deleted something.
+
 ### Using Database Commands
 
 The `bun prisma` commands allows you to use Prisma commands without needing to add in environment variables for the database config. Just run Prisma commands as you would normally, replacing `bunx prisma` with `bun prisma`.
 
 ## With Docker
 
-> **Note**: Docker is currently broken, as Bun with Prisma does not work well with Docker yet for unknown reasons. The following instructions are for when this is fixed.
+> [!NOTE]
+> Docker is currently broken, as Bun with Prisma does not work well with Docker yet for unknown reasons. The following instructions are for when this is fixed.
 >
 > These instructions will probably also work with Podman and other container runtimes.
 
@@ -180,7 +204,7 @@ You may need root privileges to run Docker commands.
 You can run CLI commands inside Docker using the following command:
 
 ```bash
-sudo docker exec -it lysand bun cli ...
+sudo docker exec -it lysand sh entrypoint.sh cli ...
 ```
 
 ### Running migrations inside Docker
@@ -188,7 +212,7 @@ sudo docker exec -it lysand bun cli ...
 You can run migrations inside Docker using the following command (if needed):
 
 ```bash
-sudo docker exec -it lysand bun migrate
+sudo docker exec -it lysand sh entrypoint.sh prisma migrate deploy
 ```
 
 ## Contributing
@@ -202,7 +226,8 @@ Contributions are welcome! Please see the [CONTRIBUTING.md](CONTRIBUTING.md) fil
 
 ## Federation
 
-> **Warning**: Federation has not been tested outside of automated tests. It is not recommended to use this software in production.
+> [!WARNING]
+> Federation has not been tested outside of automated tests. It is not recommended to use this software in production.
 
 The following extensions are currently supported or being worked on:
 - `org.lysand:custom_emojis`: Custom emojis
@@ -254,17 +279,21 @@ Working endpoints are:
 - `/api/v1/blocks`
 - `/api/v1/mutes`
 - `/api/v2/media`
+- `/api/v1/notifications`
 
 Tests needed but completed:
 
 - `/api/v1/media/:id`
+- `/api/v2/media`
 - `/api/v1/favourites`
+- `/api/v1/accounts/:id/followers`
+- `/api/v1/accounts/:id/following`
+- `/api/v2/search`
 
 Endpoints left:
 
 - `/api/v1/reports`
 - `/api/v1/accounts/:id/lists`
-- `/api/v1/accounts/:id/following`
 - `/api/v1/follow_requests`
 - `/api/v1/follow_requests/:account_id/authorize`
 - `/api/v1/follow_requests/:account_id/reject`
@@ -308,11 +337,9 @@ Endpoints left:
 - `/api/v1/lists/:id` (`GET`, `PUT`, `DELETE`)
 - `/api/v1/markers` (`GET`, `POST`)
 - `/api/v1/lists/:id/accounts` (`GET`, `POST`, `DELETE`)
-- `/api/v1/notifications`
 - `/api/v1/notifications/:id`
 - `/api/v1/notifications/clear`
 - `/api/v1/notifications/:id/dismiss`
-- `/api/v2/search`
 - `/api/v2/instance`
 - `/api/v1/instance/peers`
 - `/api/v1/instance/activity`
@@ -330,126 +357,6 @@ Endpoints left:
 
 WebSocket Streaming API also needed to be added (and push notifications)
 
-## Configuration Values
-
-Configuration can be found inside the `config.toml` file. The following values are available:
-
-### Database
-
-- `host`: The hostname or IP address of the database server. Example: `"localhost"`
-- `port`: The port number to use for the database connection. Example: `48654`
-- `username`: The username to use for the database connection. Example: `"lysand"`
-- `password`: The password to use for the database connection. Example: `"mycoolpassword"`
-- `database`: The name of the database to use. Example: `"lysand"`
-
-### HTTP
-
-- `base_url`: The base URL for the HTTP server. Example: `"https://lysand.social"`
-- `bind`: The hostname or IP address to bind the HTTP server to. Example: `"http://localhost"`
-- `bind_port`: The port number to bind the HTTP server to. Example: `"8080"`
-
-#### Security
-
-- `banned_ips`: An array of strings representing banned IPv4 or IPv6 IPs. Wildcards, networks and ranges are supported. Example: `[ "192.168.0.*" ]` (empty array)
-
-### Media
-
-- `backend`: Specifies the backend to use for media storage. Can be "local" or "s3", "local" uploads the file to the local filesystem.
-- `deduplicate_media`: When set to true, the hash of media is checked when uploading to avoid duplication.
-
-#### Conversion
-
-- `convert_images`: Whether to convert uploaded images to another format. Example: `true`
-- `convert_to`: The format to convert uploaded images to. Example: `"webp"`. Can be "jxl", "webp", "avif", "png", "jpg" or "gif".
-
-### S3
-
-- `endpoint`: The endpoint to use for the S3 server. Example: `"https://s3.example.com"`
-- `access_key`: Access key to use for S3
-- `secret_access_key`: Secret access key to use for S3
-- `bucket_name`: The bucket to use for S3 (can be left empty)
-- `region`: The region to use for S3 (can be left empty)
-- `public_url`: The public URL to access uploaded media. Example: `"https://cdn.example.com"`
-
-### SMTP
-
-- `server`: The SMTP server to use for sending emails. Example: `"smtp.example.com"`
-- `port`: The port number to use for the SMTP server. Example: `465`
-- `username`: The username to use for the SMTP server. Example: `"test@example.com"`
-- `password`: The password to use for the SMTP server. Example: `"password123"`
-- `tls`: Whether to use TLS for the SMTP server. Example: `true`
-
-### Email
-
-- `send_on_report`: Whether to send an email to moderators when a report is received. Example: `false`
-- `send_on_suspend`: Whether to send an email to moderators when a user is suspended. Example: `true`
-- `send_on_unsuspend`: Whether to send an email to moderators when a user is unsuspended. Example: `false`
-
-### Validation
-
-- `max_displayname_size`: The maximum size of a user's display name, in characters. Example: `30`
-- `max_bio_size`: The maximum size of a user's bio, in characters. Example: `160`
-- `max_note_size`: The maximum size of a user's note, in characters. Example: `500`
-- `max_avatar_size`: The maximum size of a user's avatar image, in bytes. Example: `1048576` (1 MB)
-- `max_header_size`: The maximum size of a user's header image, in bytes. Example: `2097152` (2 MB)
-- `max_media_size`: The maximum size of a media attachment, in bytes. Example: `5242880` (5 MB)
-- `max_media_attachments`: The maximum number of media attachments allowed per post. Example: `4`
-- `max_media_description_size`: The maximum size of a media attachment's description, in characters. Example: `100`
-- `max_username_size`: The maximum size of a user's username, in characters. Example: `20`
-- `username_blacklist`: An array of strings representing usernames that are not allowed to be used by users. Defaults are from Akkoma. Example: `["admin", "moderator"]`
-- `blacklist_tempmail`: Whether to blacklist known temporary email providers. Example: `true`
-- `email_blacklist`: Additional email providers to blacklist. Example: `["example.com", "test.com"]`
-- `url_scheme_whitelist`: An array of strings representing valid URL schemes. URLs that do not use one of these schemes will be parsed as text. Example: `["http", "https"]`
-- `allowed_mime_types`: An array of strings representing allowed MIME types for media attachments. Example: `["image/jpeg", "image/png", "video/mp4"]`
-
-### Defaults
-
-- `visibility`: The default visibility for new notes. Example: `"public"`
-- `language`: The default language for new notes. Example: `"en"`
-- `avatar`: The default avatar URL. Example: `""` (empty string)
-- `header`: The default header URL. Example: `""` (empty string)
-
-### ActivityPub
-
-> **Note**: These options do nothing and date back to when Lysand had ActivityPub support. They will be removed in a future version.
-
-- `use_tombstones`: Whether to use ActivityPub Tombstones instead of deleting objects. Example: `true`
-- `fetch_all_collection_members`: Whether to fetch all members of collections (followers, following, etc) when receiving them. Example: `false`
-- `reject_activities`: An array of instance domain names without "https" or glob patterns. Rejects all activities from these instances, simply doesn't save them at all. Example: `[ "mastodon.social" ]`
-- `force_followers_only`: An array of instance domain names without "https" or glob patterns. Force posts from this instance to be followers only. Example: `[ "mastodon.social" ]`
-- `discard_reports`: An array of instance domain names without "https" or glob patterns. Discard all reports from these instances. Example: `[ "mastodon.social" ]`
-- `discard_deletes`: An array of instance domain names without "https" or glob patterns. Discard all deletes from these instances. Example: `[ "mastodon.social" ]`
-- `discard_updates`: An array of instance domain names without "https" or glob patterns. Discard all updates (edits) from these instances. Example: `[]`
-- `discard_banners`: An array of instance domain names without "https" or glob patterns. Discard all banners from these instances. Example: `[ "mastodon.social" ]`
-- `discard_avatars`: An array of instance domain names without "https" or glob patterns. Discard all avatars from these instances. Example: `[ "mastodon.social" ]`
-- `discard_follows`: An array of instance domain names without "https" or glob patterns. Discard all follow requests from these instances. Example: `[]`
-- `force_sensitive`: An array of instance domain names without "https" or glob patterns. Force set these instances' media as sensitive. Example: `[ "mastodon.social" ]`
-- `remove_media`: An array of instance domain names without "https" or glob patterns. Remove these instances' media. Example: `[ "mastodon.social" ]`
-
-### Filters
-
-- `note_filters`: An array of regex filters to drop notes from new activities. Example: `["(https?://)?(www\\.)?youtube\\.com/watch\\?v=[a-zA-Z0-9_-]+", "(https?://)?(www\\.)?youtu\\.be/[a-zA-Z0-9_-]+"]`
-- `username_filters`: An array of regex filters to drop users from new activities based on their username. Example: `[ "^spammer-[a-z]" ]`
-- `displayname_filters`: An array of regex filters to drop users from new activities based on their display name. Example: `[ "^spammer-[a-z]" ]`
-- `bio_filters`: An array of regex filters to drop users from new activities based on their bio. Example: `[ "badword" ]`
-- `emoji_filters`: An array of regex filters to drop users from new activities based on their emoji usage. Example: `[ ":bademoji:" ]`
-
-### Logging
-
-- `log_requests`: Whether to log all requests. Example: `true`
-- `log_requests_verbose`: Whether to log request and their contents. Example: `false`
-- `log_filters`: Whether to log all filtered objects. Example: `true`
-
-### Ratelimits
-
-- `duration_coeff`: The amount to multiply every route's duration by. Example: `1.0`
-- `max_coeff`: The amount to multiply every route's max by. Example: `1.0`
-
-### Custom Ratelimits
-
-- `"/api/v1/timelines/public"`: An object representing a custom ratelimit for the specified API route. Example: `{ duration = 60, max = 200 }`
-
-
 ## License
 
-This project is licensed under the [AGPL-3.0](LICENSE).
\ No newline at end of file
+This project is licensed under the [AGPL-3.0](LICENSE).
diff --git a/benchmarks/timelines.ts b/benchmarks/timelines.ts
index 2804f691..b5348b69 100644
--- a/benchmarks/timelines.ts
+++ b/benchmarks/timelines.ts
@@ -2,10 +2,10 @@
  * Usage: TOKEN=your_token_here bun benchmark:timeline <request_count>
  */
 
-import { getConfig } from "@config";
 import chalk from "chalk";
+import { ConfigManager } from "config-manager";
 
-const config = getConfig();
+const config = await new ConfigManager({}).getConfig();
 
 const token = process.env.TOKEN;
 const requestCount = Number(process.argv[2]) || 100;
diff --git a/build.ts b/build.ts
new file mode 100644
index 00000000..eec9642e
--- /dev/null
+++ b/build.ts
@@ -0,0 +1,43 @@
+// Delete dist directory
+import { rm, cp, mkdir, exists } from "fs/promises";
+
+if (!(await exists("./pages/dist"))) {
+	console.log("Please build the Vite server first, or use `bun prod-build`");
+	process.exit(1);
+}
+
+console.log(`Building at ${process.cwd()}`);
+
+await rm("./dist", { recursive: true });
+
+await mkdir(process.cwd() + "/dist");
+
+//bun build --entrypoints ./index.ts ./prisma.ts ./cli.ts --outdir dist --target bun --splitting --minify --external bullmq,@prisma/client
+await Bun.build({
+	entrypoints: [
+		process.cwd() + "/index.ts",
+		process.cwd() + "/prisma.ts",
+		process.cwd() + "/cli.ts",
+	],
+	outdir: process.cwd() + "/dist",
+	target: "bun",
+	splitting: true,
+	minify: true,
+	external: ["bullmq"],
+}).then(output => {
+	if (!output.success) {
+		console.log(output.logs);
+	}
+});
+
+// Create pages directory
+// mkdir ./dist/pages
+await mkdir(process.cwd() + "/dist/pages");
+
+// Copy Vite build output to dist
+// cp -r ./pages/dist ./dist/pages
+await cp(process.cwd() + "/pages/dist", process.cwd() + "/dist/pages/", {
+	recursive: true,
+});
+
+console.log(`Built!`);
diff --git a/bun.lockb b/bun.lockb
index ae9680ac..f2a6bae9 100755
Binary files a/bun.lockb and b/bun.lockb differ
diff --git a/bunfig.toml b/bunfig.toml
new file mode 100644
index 00000000..bea1efe1
--- /dev/null
+++ b/bunfig.toml
@@ -0,0 +1,2 @@
+[install.scopes]
+"@jsr" = "https://npm.jsr.io"
diff --git a/classes/media.ts b/classes/media.ts
deleted file mode 100644
index 9d40ebe0..00000000
--- a/classes/media.ts
+++ /dev/null
@@ -1,273 +0,0 @@
-import type { GetObjectCommandOutput } from "@aws-sdk/client-s3";
-import {
-	GetObjectCommand,
-	PutObjectCommand,
-	S3Client,
-} from "@aws-sdk/client-s3";
-import type { ConfigType } from "@config";
-import sharp from "sharp";
-import { exists, mkdir } from "fs/promises";
-class MediaBackend {
-	backend: string;
-
-	constructor(backend: string) {
-		this.backend = backend;
-	}
-
-	/**
-	 * Adds media to the media backend
-	 * @param media
-	 * @returns The hash of the file in SHA-256 (hex format) with the file extension added to it
-	 */
-	async addMedia(media: File) {
-		const hash = new Bun.SHA256()
-			.update(await media.arrayBuffer())
-			.digest("hex");
-
-		return `${hash}.${media.name.split(".").pop()}`;
-	}
-
-	async convertMedia(media: File, config: ConfigType) {
-		const sharpCommand = sharp(await media.arrayBuffer());
-
-		// Rename ".jpg" files to ".jpeg" to avoid sharp errors
-		let name = media.name;
-		if (media.name.endsWith(".jpg")) {
-			name = media.name.replace(".jpg", ".jpeg");
-		}
-
-		const fileFormatToConvertTo = config.media.conversion.convert_to;
-
-		switch (fileFormatToConvertTo) {
-			case "png":
-				return new File(
-					[(await sharpCommand.png().toBuffer()).buffer],
-					// Replace the file extension with PNG
-					name.replace(/\.[^/.]+$/, ".png"),
-					{
-						type: "image/png",
-					}
-				);
-			case "webp":
-				return new File(
-					[(await sharpCommand.webp().toBuffer()).buffer],
-					// Replace the file extension with WebP
-					name.replace(/\.[^/.]+$/, ".webp"),
-					{
-						type: "image/webp",
-					}
-				);
-			case "jpeg":
-				return new File(
-					[(await sharpCommand.jpeg().toBuffer()).buffer],
-					// Replace the file extension with JPEG
-					name.replace(/\.[^/.]+$/, ".jpeg"),
-					{
-						type: "image/jpeg",
-					}
-				);
-			case "avif":
-				return new File(
-					[(await sharpCommand.avif().toBuffer()).buffer],
-					// Replace the file extension with AVIF
-					name.replace(/\.[^/.]+$/, ".avif"),
-					{
-						type: "image/avif",
-					}
-				);
-			// Needs special build of libvips
-			case "jxl":
-				return new File(
-					[(await sharpCommand.jxl().toBuffer()).buffer],
-					// Replace the file extension with JXL
-					name.replace(/\.[^/.]+$/, ".jxl"),
-					{
-						type: "image/jxl",
-					}
-				);
-			case "heif":
-				return new File(
-					[(await sharpCommand.heif().toBuffer()).buffer],
-					// Replace the file extension with HEIF
-					name.replace(/\.[^/.]+$/, ".heif"),
-					{
-						type: "image/heif",
-					}
-				);
-			default:
-				return media;
-		}
-	}
-
-	/**
-	 * Retrieves element from media backend by hash
-	 * @param hash The hash of the element in SHA-256 hex format
-	 * @param extension The extension of the file
-	 * @returns The file as a File object
-	 */
-	// eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
-	async getMediaByHash(
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
-		hash: string
-	): Promise<File | null> {
-		return new File([], "test");
-	}
-}
-
-/**
- * S3 Backend, stores files in S3
- */
-export class S3Backend extends MediaBackend {
-	client: S3Client;
-	config: ConfigType;
-
-	constructor(config: ConfigType) {
-		super("s3");
-
-		this.config = config;
-
-		this.client = new S3Client({
-			endpoint: this.config.s3.endpoint,
-			region: this.config.s3.region || "auto",
-			credentials: {
-				accessKeyId: this.config.s3.access_key,
-				secretAccessKey: this.config.s3.secret_access_key,
-			},
-		});
-	}
-
-	async addMedia(media: File): Promise<string> {
-		if (this.config.media.conversion.convert_images) {
-			media = await this.convertMedia(media, this.config);
-		}
-
-		const hash = await super.addMedia(media);
-
-		if (!hash) {
-			throw new Error("Failed to hash file");
-		}
-
-		// Check if file is already present
-		const existingFile = await this.getMediaByHash(hash);
-
-		if (existingFile) {
-			// File already exists, so return the hash without uploading it
-			return hash;
-		}
-
-		const command = new PutObjectCommand({
-			Bucket: this.config.s3.bucket_name,
-			Key: hash,
-			Body: Buffer.from(await media.arrayBuffer()),
-			ContentType: media.type,
-			ContentLength: media.size,
-			Metadata: {
-				"x-amz-meta-original-name": media.name,
-			},
-		});
-
-		const response = await this.client.send(command);
-
-		if (response.$metadata.httpStatusCode !== 200) {
-			throw new Error("Failed to upload file");
-		}
-
-		return hash;
-	}
-
-	async getMediaByHash(hash: string): Promise<File | null> {
-		const command = new GetObjectCommand({
-			Bucket: this.config.s3.bucket_name,
-			Key: hash,
-		});
-
-		let response: GetObjectCommandOutput;
-
-		try {
-			response = await this.client.send(command);
-		} catch {
-			return null;
-		}
-
-		if (response.$metadata.httpStatusCode !== 200) {
-			throw new Error("Failed to get file");
-		}
-
-		const body = await response.Body?.transformToByteArray();
-
-		if (!body) {
-			throw new Error("Failed to get file");
-		}
-
-		return new File([body], hash, {
-			type: response.ContentType,
-		});
-	}
-}
-
-/**
- * Local backend, stores files on filesystem
- */
-export class LocalBackend extends MediaBackend {
-	config: ConfigType;
-
-	constructor(config: ConfigType) {
-		super("local");
-
-		this.config = config;
-	}
-
-	async addMedia(media: File): Promise<string> {
-		if (this.config.media.conversion.convert_images) {
-			media = await this.convertMedia(media, this.config);
-		}
-
-		const hash = await super.addMedia(media);
-
-		if (!(await exists(`${process.cwd()}/uploads`))) {
-			await mkdir(`${process.cwd()}/uploads`);
-		}
-
-		await Bun.write(Bun.file(`${process.cwd()}/uploads/${hash}`), media);
-
-		return hash;
-	}
-
-	async getMediaByHash(hash: string): Promise<File | null> {
-		const file = Bun.file(`${process.cwd()}/uploads/${hash}`);
-
-		if (!(await file.exists())) {
-			return null;
-		}
-
-		return new File([await file.arrayBuffer()], `${hash}`, {
-			type: file.type,
-		});
-	}
-}
-
-export const uploadFile = (file: File, config: ConfigType) => {
-	const backend = config.media.backend;
-
-	if (backend === "local") {
-		return new LocalBackend(config).addMedia(file);
-	} else if (backend === "s3") {
-		return new S3Backend(config).addMedia(file);
-	}
-};
-
-export const getFile = (
-	hash: string,
-	extension: string,
-	config: ConfigType
-) => {
-	const backend = config.media.backend;
-
-	if (backend === "local") {
-		return new LocalBackend(config).getMediaByHash(hash);
-	} else if (backend === "s3") {
-		return new S3Backend(config).getMediaByHash(hash);
-	}
-
-	return null;
-};
diff --git a/cli.ts b/cli.ts
index a42f4d77..01f0cb19 100644
--- a/cli.ts
+++ b/cli.ts
@@ -1,513 +1,1751 @@
-import type { Prisma } from "@prisma/client";
 import chalk from "chalk";
-import { client } from "~database/datasource";
 import { createNewLocalUser } from "~database/entities/User";
 import Table from "cli-table";
+import { rebuildSearchIndexes, MeiliIndexType } from "@meilisearch";
+import { getUrl } from "~database/entities/Attachment";
+import extract from "extract-zip";
+import { client } from "~database/datasource";
+import { CliBuilder, CliCommand } from "cli-parser";
+import { CliParameterType } from "~packages/cli-parser/cli-builder.type";
+import { ConfigManager } from "~packages/config-manager";
+import { Parser } from "@json2csv/plainjs";
+import type { Prisma } from "@prisma/client";
+import { MediaBackend } from "media-manager";
+import { mkdtemp } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
 
 const args = process.argv;
 
-/**
- * Make the text have a width of 20 characters, padding with gray dots
- * Text can be a Chalk string, in which case formatting codes should not be counted in text length
- * @param text The text to align
- */
-const alignDots = (text: string, length = 20) => {
-	// Remove formatting codes
-	// eslint-disable-next-line no-control-regex
-	const textLength = text.replace(/\u001b\[\d+m/g, "").length;
-	const dots = ".".repeat(length - textLength);
-	return `${text}${chalk.gray(dots)}`;
-};
+const config = await new ConfigManager({}).getConfig();
 
-const alignDotsSmall = (text: string, length = 16) => alignDots(text, length);
+const cliBuilder = new CliBuilder([
+	new CliCommand<{
+		username: string;
+		password: string;
+		email: string;
+		admin: boolean;
+		help: boolean;
+	}>(
+		["user", "create"],
+		[
+			{
+				name: "username",
+				type: CliParameterType.STRING,
+				description: "Username of the user",
+				needsValue: true,
+				positioned: false,
+			},
+			{
+				name: "password",
+				type: CliParameterType.STRING,
+				description: "Password of the user",
+				needsValue: true,
+				positioned: false,
+			},
+			{
+				name: "email",
+				type: CliParameterType.STRING,
+				description: "Email of the user",
+				needsValue: true,
+				positioned: false,
+			},
+			{
+				name: "admin",
+				type: CliParameterType.BOOLEAN,
+				description: "Make the user an admin",
+				needsValue: false,
+				positioned: false,
+			},
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const { username, password, email, admin, help } = args;
 
-const help = `
-${chalk.bold(`Usage: bun cli <command> ${chalk.blue("[...flags]")} [...args]`)}
-
-${chalk.bold("Commands:")}
-    ${alignDots(chalk.blue("help"), 24)} Show this help message
-    ${alignDots(chalk.blue("user"), 24)} Manage users
-        ${alignDots(chalk.blue("create"))} Create a new user
-            ${alignDotsSmall(chalk.green("username"))} Username of the user
-            ${alignDotsSmall(chalk.green("password"))} Password of the user
-            ${alignDotsSmall(chalk.green("email"))} Email of the user
-            ${alignDotsSmall(
-				chalk.yellow("--admin")
-			)} Make the user an admin (optional)
-            ${chalk.bold("Example:")} ${chalk.bgGray(
-				`bun cli user create admin password123 admin@gmail.com --admin`
-			)}
-        ${alignDots(chalk.blue("delete"))} Delete a user
-            ${alignDotsSmall(chalk.green("username"))} Username of the user
-            ${chalk.bold("Example:")} ${chalk.bgGray(
-				`bun cli user delete admin`
-			)}
-        ${alignDots(chalk.blue("list"))} List all users
-            ${alignDotsSmall(
-				chalk.yellow("--admins")
-			)} List only admins (optional)
-            ${chalk.bold("Example:")} ${chalk.bgGray(`bun cli user list`)}
-        ${alignDots(chalk.blue("search"))} Search for a user
-            ${alignDotsSmall(chalk.green("query"))} Query to search for
-            ${alignDotsSmall(
-				chalk.yellow("--displayname")
-			)} Search by display name (optional)
-            ${alignDotsSmall(chalk.yellow("--bio"))} Search in bio (optional)
-            ${alignDotsSmall(
-				chalk.yellow("--local")
-			)} Search in local users (optional)
-            ${alignDotsSmall(
-				chalk.yellow("--remote")
-			)} Search in remote users (optional)
-            ${alignDotsSmall(
-				chalk.yellow("--email")
-			)} Search in emails (optional)
-            ${alignDotsSmall(chalk.yellow("--json"))} Output as JSON (optional)
-            ${alignDotsSmall(chalk.yellow("--csv"))} Output as CSV (optional)
-            ${chalk.bold("Example:")} ${chalk.bgGray(
-				`bun cli user search admin`
-			)}
-    ${alignDots(chalk.blue("note"), 24)} Manage notes
-        ${alignDots(chalk.blue("delete"))} Delete a note
-            ${alignDotsSmall(chalk.green("id"))} ID of the note
-            ${chalk.bold("Example:")} ${chalk.bgGray(
-				`bun cli note delete 018c1838-6e0b-73c4-a157-a91ea4e25d1d`
-			)}
-        ${alignDots(chalk.blue("search"))} Search for a status
-            ${alignDotsSmall(chalk.green("query"))} Query to search for
-            ${alignDotsSmall(
-				chalk.yellow("--local")
-			)} Search in local statuses (optional)
-            ${alignDotsSmall(
-				chalk.yellow("--remote")
-			)} Search in remote statuses (optional)
-            ${alignDotsSmall(chalk.yellow("--json"))} Output as JSON (optional)
-            ${alignDotsSmall(chalk.yellow("--csv"))} Output as CSV (optional)
-            ${chalk.bold("Example:")} ${chalk.bgGray(
-				`bun cli note search hello`
-			)}
-            
-`;
-
-if (args.length < 3) {
-	console.log(help);
-	process.exit(0);
-}
-
-const command = args[2];
-
-switch (command) {
-	case "help":
-		console.log(help);
-		break;
-	case "user":
-		switch (args[3]) {
-			case "create": {
-				// Check if --admin flag is provided
-				const argsWithFlags = args.filter(arg => arg.startsWith("--"));
-				const argsWithoutFlags = args.filter(
-					arg => !arg.startsWith("--")
-				);
-
-				const username = argsWithoutFlags[4];
-				const password = argsWithoutFlags[5];
-				const email = argsWithoutFlags[6];
-
-				const admin = argsWithFlags.includes("--admin");
-
-				// Check if username, password and email are provided
-				if (!username || !password || !email) {
-					console.log(
-						`${chalk.red(`✗`)} Missing username, password or email`
-					);
-					process.exit(1);
-				}
-
-				// Check if user already exists
-				const user = await client.user.findFirst({
-					where: {
-						OR: [{ username }, { email }],
-					},
-				});
-
-				if (user) {
-					console.log(`${chalk.red(`✗`)} User already exists`);
-					process.exit(1);
-				}
-
-				// Create user
-				const newUser = await createNewLocalUser({
-					email: email,
-					password: password,
-					username: username,
-					admin: admin,
-				});
-
-				console.log(
-					`${chalk.green(`✓`)} Created user ${chalk.blue(
-						newUser.username
-					)}${admin ? chalk.green(" (admin)") : ""}`
-				);
-				break;
+			if (help) {
+				instance.displayHelp();
+				return 0;
 			}
-			case "delete": {
-				const username = args[4];
 
-				if (!username) {
-					console.log(`${chalk.red(`✗`)} Missing username`);
-					process.exit(1);
+			// Check if username, password and email are provided
+			if (!username || !password || !email) {
+				console.log(
+					`${chalk.red(`✗`)} Missing username, password or email`
+				);
+				return 1;
+			}
+
+			// Check if user already exists
+			const user = await client.user.findFirst({
+				where: {
+					OR: [{ username }, { email }],
+				},
+			});
+
+			if (user) {
+				if (user.username === username) {
+					console.log(
+						`${chalk.red(`✗`)} User with username ${chalk.blue(username)} already exists`
+					);
+				} else {
+					console.log(
+						`${chalk.red(`✗`)} User with email ${chalk.blue(email)} already exists`
+					);
+				}
+				return 1;
+			}
+
+			// Create user
+			const newUser = await createNewLocalUser({
+				email: email,
+				password: password,
+				username: username,
+				admin: admin,
+			});
+
+			console.log(
+				`${chalk.green(`✓`)} Created user ${chalk.blue(
+					newUser.username
+				)}${admin ? chalk.green(" (admin)") : ""}`
+			);
+
+			return 0;
+		},
+		"Creates a new user",
+		"bun cli user create --username admin --password password123 --email email@email.com"
+	),
+	new CliCommand<{
+		username: string;
+		help: boolean;
+		noconfirm: boolean;
+	}>(
+		["user", "delete"],
+		[
+			{
+				name: "username",
+				type: CliParameterType.STRING,
+				description: "Username of the user",
+				needsValue: true,
+				positioned: true,
+			},
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+			},
+			{
+				name: "noconfirm",
+				shortName: "y",
+				type: CliParameterType.EMPTY,
+				description: "Skip confirmation",
+				needsValue: false,
+				positioned: false,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const { username, help } = args;
+
+			if (help) {
+				instance.displayHelp();
+				return 0;
+			}
+
+			if (!username) {
+				console.log(`${chalk.red(`✗`)} Missing username`);
+				return 1;
+			}
+
+			const user = await client.user.findFirst({
+				where: {
+					username: username,
+				},
+			});
+
+			if (!user) {
+				console.log(`${chalk.red(`✗`)} User not found`);
+				return 1;
+			}
+
+			if (!args.noconfirm) {
+				process.stdout.write(
+					`Are you sure you want to delete user ${chalk.blue(
+						user.username
+					)}?\n${chalk.red(chalk.bold("This is a destructive action and cannot be undone!"))} [y/N] `
+				);
+
+				for await (const line of console) {
+					if (line.trim().toLowerCase() === "y") {
+						break;
+					} else {
+						console.log(`${chalk.red(`✗`)} Deletion cancelled`);
+						return 0;
+					}
+				}
+			}
+
+			await client.user.delete({
+				where: {
+					id: user.id,
+				},
+			});
+
+			console.log(
+				`${chalk.green(`✓`)} Deleted user ${chalk.blue(user.username)}`
+			);
+
+			return 0;
+		},
+		"Deletes a user",
+		"bun cli user delete --username admin"
+	),
+	new CliCommand<{
+		admins: boolean;
+		help: boolean;
+		format: string;
+		limit: number;
+		redact: boolean;
+		fields: string[];
+	}>(
+		["user", "list"],
+		[
+			{
+				name: "admins",
+				type: CliParameterType.BOOLEAN,
+				description: "List only admins",
+				needsValue: false,
+				positioned: false,
+			},
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+			},
+			{
+				name: "format",
+				type: CliParameterType.STRING,
+				description: "Output format (can be json or csv)",
+				needsValue: true,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "limit",
+				type: CliParameterType.NUMBER,
+				description:
+					"Limit the number of users to list (defaults to 200)",
+				needsValue: true,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "redact",
+				type: CliParameterType.BOOLEAN,
+				description:
+					"Redact sensitive information (such as password hashes, emails or keys)",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "fields",
+				type: CliParameterType.ARRAY,
+				description:
+					"If provided, restricts output to these fields (comma-separated)",
+				needsValue: true,
+				positioned: false,
+				optional: true,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const { admins, help } = args;
+
+			if (help) {
+				instance.displayHelp();
+				return 0;
+			}
+
+			if (args.format && !["json", "csv"].includes(args.format)) {
+				console.log(`${chalk.red(`✗`)} Invalid format`);
+				return 1;
+			}
+
+			const users = await client.user.findMany({
+				where: {
+					isAdmin: admins || undefined,
+				},
+				take: args.limit ?? 200,
+				include: {
+					instance: true,
+				},
+			});
+
+			if (args.redact) {
+				for (const user of users) {
+					user.email = "[REDACTED]";
+					user.password = "[REDACTED]";
+					user.publicKey = "[REDACTED]";
+					user.privateKey = "[REDACTED]";
+				}
+			}
+
+			if (args.fields) {
+				for (const user of users) {
+					const keys = Object.keys(user);
+					for (const key of keys) {
+						if (!args.fields.includes(key)) {
+							// @ts-expect-error Shouldn't cause issues in this case
+							// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+							delete user[key];
+						}
+					}
+				}
+			}
+
+			if (args.format === "json") {
+				console.log(JSON.stringify(users, null, 4));
+				return 0;
+			} else if (args.format == "csv") {
+				const parser = new Parser({});
+				console.log(parser.parse(users));
+				return 0;
+			}
+
+			console.log(
+				`${chalk.green(`✓`)} Found ${chalk.blue(users.length)} users (limit ${args.limit ?? 200})`
+			);
+
+			const tableHead = {
+				username: chalk.white(chalk.bold("Username")),
+				email: chalk.white(chalk.bold("Email")),
+				displayName: chalk.white(chalk.bold("Display Name")),
+				isAdmin: chalk.white(chalk.bold("Admin?")),
+				instance: chalk.white(chalk.bold("Instance URL")),
+				createdAt: chalk.white(chalk.bold("Created At")),
+				id: chalk.white(chalk.bold("Internal UUID")),
+			};
+
+			// Only keep the fields specified if --fields is provided
+			if (args.fields) {
+				const keys = Object.keys(tableHead);
+				for (const key of keys) {
+					if (!args.fields.includes(key)) {
+						// @ts-expect-error This is fine
+						// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+						delete tableHead[key];
+					}
+				}
+			}
+
+			const table = new Table({
+				head: Object.values(tableHead),
+			});
+
+			for (const user of users) {
+				// Print table of users
+				const data = {
+					username: () => chalk.yellow(`@${user.username}`),
+					email: () => chalk.green(user.email),
+					displayName: () => chalk.blue(user.displayName),
+					isAdmin: () => chalk.red(user.isAdmin ? "Yes" : "No"),
+					instance: () =>
+						chalk.blue(
+							user.instance ? user.instance.base_url : "Local"
+						),
+					createdAt: () => chalk.blue(user.createdAt.toISOString()),
+					id: () => chalk.blue(user.id),
+				};
+
+				// Only keep the fields specified if --fields is provided
+				if (args.fields) {
+					const keys = Object.keys(data);
+					for (const key of keys) {
+						if (!args.fields.includes(key)) {
+							// @ts-expect-error This is fine
+							// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+							delete data[key];
+						}
+					}
 				}
 
-				const user = await client.user.findFirst({
-					where: {
-						username: username,
+				table.push(Object.values(data).map(fn => fn()));
+			}
+
+			console.log(table.toString());
+
+			return 0;
+		},
+		"Lists all users",
+		"bun cli user list"
+	),
+	new CliCommand<{
+		query: string;
+		fields: string[];
+		format: string;
+		help: boolean;
+		"case-sensitive": boolean;
+		limit: number;
+		redact: boolean;
+	}>(
+		["user", "search"],
+		[
+			{
+				name: "query",
+				type: CliParameterType.STRING,
+				description: "Query to search for",
+				needsValue: true,
+				positioned: true,
+			},
+			{
+				name: "fields",
+				type: CliParameterType.ARRAY,
+				description: "Fields to search in",
+				needsValue: true,
+				positioned: false,
+			},
+			{
+				name: "format",
+				type: CliParameterType.STRING,
+				description: "Output format (can be json or csv)",
+				needsValue: true,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+			},
+			{
+				name: "case-sensitive",
+				shortName: "c",
+				type: CliParameterType.EMPTY,
+				description: "Case-sensitive search",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "limit",
+				type: CliParameterType.NUMBER,
+				description: "Limit the number of users to list (default 20)",
+				needsValue: true,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "redact",
+				type: CliParameterType.BOOLEAN,
+				description:
+					"Redact sensitive information (such as password hashes, emails or keys)",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const {
+				query,
+				fields = [],
+				help,
+				limit = 20,
+				"case-sensitive": caseSensitive = false,
+				redact,
+			} = args;
+
+			if (help) {
+				instance.displayHelp();
+				return 0;
+			}
+
+			if (!query) {
+				console.log(`${chalk.red(`✗`)} Missing query parameter`);
+				return 1;
+			}
+
+			if (fields.length === 0) {
+				console.log(`${chalk.red(`✗`)} Missing fields parameter`);
+				return 1;
+			}
+
+			const queries: Prisma.UserWhereInput[] = [];
+
+			for (const field of fields) {
+				queries.push({
+					[field]: {
+						contains: query,
+						mode: caseSensitive ? "default" : "insensitive",
 					},
 				});
+			}
 
-				if (!user) {
-					console.log(`${chalk.red(`✗`)} User not found`);
-					process.exit(1);
+			const users = await client.user.findMany({
+				where: {
+					OR: queries,
+				},
+				include: {
+					instance: true,
+				},
+				take: limit,
+			});
+
+			if (redact) {
+				for (const user of users) {
+					user.email = "[REDACTED]";
+					user.password = "[REDACTED]";
+					user.publicKey = "[REDACTED]";
+					user.privateKey = "[REDACTED]";
 				}
+			}
 
-				await client.user.delete({
-					where: {
-						id: user.id,
+			if (args.format === "json") {
+				console.log(JSON.stringify(users, null, 4));
+				return 0;
+			} else if (args.format === "csv") {
+				const parser = new Parser({});
+				console.log(parser.parse(users));
+				return 0;
+			}
+
+			console.log(
+				`${chalk.green(`✓`)} Found ${chalk.blue(users.length)} users (limit ${limit})`
+			);
+
+			const table = new Table({
+				head: [
+					chalk.white(chalk.bold("Username")),
+					chalk.white(chalk.bold("Email")),
+					chalk.white(chalk.bold("Display Name")),
+					chalk.white(chalk.bold("Admin?")),
+					chalk.white(chalk.bold("Instance URL")),
+				],
+			});
+
+			for (const user of users) {
+				table.push([
+					chalk.yellow(`@${user.username}`),
+					chalk.green(user.email),
+					chalk.blue(user.displayName),
+					chalk.red(user.isAdmin ? "Yes" : "No"),
+					chalk.blue(
+						user.instanceId ? user.instance?.base_url : "Local"
+					),
+				]);
+			}
+
+			console.log(table.toString());
+
+			return 0;
+		},
+		"Searches for a user",
+		"bun cli user search bob --fields email,username"
+	),
+
+	new CliCommand<{
+		username: string;
+		"issuer-id": string;
+		"server-id": string;
+		help: boolean;
+	}>(
+		["user", "oidc", "connect"],
+		[
+			{
+				name: "username",
+				type: CliParameterType.STRING,
+				description: "Username of the local account",
+				needsValue: true,
+				positioned: true,
+			},
+			{
+				name: "issuer-id",
+				type: CliParameterType.STRING,
+				description: "ID of the OpenID Connect issuer in config",
+				needsValue: true,
+				positioned: false,
+			},
+			{
+				name: "server-id",
+				type: CliParameterType.STRING,
+				description: "ID of the user on the OpenID Connect server",
+				needsValue: true,
+				positioned: false,
+			},
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const {
+				username,
+				"issuer-id": issuerId,
+				"server-id": serverId,
+				help,
+			} = args;
+
+			if (help) {
+				instance.displayHelp();
+				return 0;
+			}
+
+			if (!username || !issuerId || !serverId) {
+				console.log(`${chalk.red(`✗`)} Missing username, issuer or ID`);
+				return 1;
+			}
+
+			// Check if issuerId is valid
+			if (!config.oidc.providers.find(p => p.id === issuerId)) {
+				console.log(`${chalk.red(`✗`)} Invalid issuer ID`);
+				return 1;
+			}
+
+			const user = await client.user.findFirst({
+				where: {
+					username: username,
+				},
+				include: {
+					linkedOpenIdAccounts: true,
+				},
+			});
+
+			if (!user) {
+				console.log(`${chalk.red(`✗`)} User not found`);
+				return 1;
+			}
+
+			if (user.linkedOpenIdAccounts.find(a => a.issuerId === issuerId)) {
+				console.log(
+					`${chalk.red(`✗`)} User ${chalk.blue(
+						user.username
+					)} is already connected to this OpenID Connect issuer with another account`
+				);
+				return 1;
+			}
+
+			// Connect the OpenID account
+			await client.user.update({
+				where: {
+					id: user.id,
+				},
+				data: {
+					linkedOpenIdAccounts: {
+						create: {
+							issuerId: issuerId,
+							serverId: serverId,
+						},
+					},
+				},
+			});
+
+			console.log(
+				`${chalk.green(`✓`)} Connected OpenID Connect account to user ${chalk.blue(
+					user.username
+				)}`
+			);
+
+			return 0;
+		},
+		"Connects an OpenID Connect account to a local account",
+		"bun cli user oidc connect admin google 123456789"
+	),
+	new CliCommand<{
+		"server-id": string;
+		help: boolean;
+	}>(
+		["user", "oidc", "disconnect"],
+		[
+			{
+				name: "server-id",
+				type: CliParameterType.STRING,
+				description: "Server ID of the OpenID Connect account",
+				needsValue: true,
+				positioned: true,
+			},
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const { "server-id": id, help } = args;
+
+			if (help) {
+				instance.displayHelp();
+				return 0;
+			}
+
+			if (!id) {
+				console.log(`${chalk.red(`✗`)} Missing ID`);
+				return 1;
+			}
+
+			const account = await client.openIdAccount.findFirst({
+				where: {
+					serverId: id,
+				},
+				include: {
+					User: true,
+				},
+			});
+
+			if (!account) {
+				console.log(`${chalk.red(`✗`)} Account not found`);
+				return 1;
+			}
+
+			await client.openIdAccount.delete({
+				where: {
+					id: account.id,
+				},
+			});
+
+			console.log(
+				`${chalk.green(`✓`)} Disconnected OpenID account from user ${chalk.blue(account.User?.username)}`
+			);
+
+			return 0;
+		},
+		"Disconnects an OpenID Connect account from a local account",
+		"bun cli user oidc disconnect 123456789"
+	),
+	new CliCommand<{
+		id: string;
+		help: boolean;
+		noconfirm: boolean;
+	}>(
+		["note", "delete"],
+		[
+			{
+				name: "id",
+				type: CliParameterType.STRING,
+				description: "ID of the note",
+				needsValue: true,
+				positioned: true,
+			},
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+			},
+			{
+				name: "noconfirm",
+				shortName: "y",
+				type: CliParameterType.EMPTY,
+				description: "Skip confirmation",
+				needsValue: false,
+				positioned: false,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const { id, help } = args;
+
+			if (help) {
+				instance.displayHelp();
+				return 0;
+			}
+
+			if (!id) {
+				console.log(`${chalk.red(`✗`)} Missing ID`);
+				return 1;
+			}
+
+			const note = await client.status.findFirst({
+				where: {
+					id: id,
+				},
+			});
+
+			if (!note) {
+				console.log(`${chalk.red(`✗`)} Note not found`);
+				return 1;
+			}
+
+			if (!args.noconfirm) {
+				process.stdout.write(
+					`Are you sure you want to delete note ${chalk.blue(
+						note.id
+					)}?\n${chalk.red(chalk.bold("This is a destructive action and cannot be undone!"))} [y/N] `
+				);
+
+				for await (const line of console) {
+					if (line.trim().toLowerCase() === "y") {
+						break;
+					} else {
+						console.log(`${chalk.red(`✗`)} Deletion cancelled`);
+						return 0;
+					}
+				}
+			}
+
+			await client.status.delete({
+				where: {
+					id: note.id,
+				},
+			});
+
+			console.log(
+				`${chalk.green(`✓`)} Deleted note ${chalk.blue(note.id)}`
+			);
+
+			return 0;
+		},
+		"Deletes a note",
+		"bun cli note delete 018c1838-6e0b-73c4-a157-a91ea4e25d1d"
+	),
+	new CliCommand<{
+		query: string;
+		fields: string[];
+		local: boolean;
+		remote: boolean;
+		format: string;
+		help: boolean;
+		"case-sensitive": boolean;
+		limit: number;
+		redact: boolean;
+	}>(
+		["note", "search"],
+		[
+			{
+				name: "query",
+				type: CliParameterType.STRING,
+				description: "Query to search for",
+				needsValue: true,
+				positioned: true,
+			},
+			{
+				name: "fields",
+				type: CliParameterType.ARRAY,
+				description: "Fields to search in",
+				needsValue: true,
+				positioned: false,
+			},
+			{
+				name: "local",
+				type: CliParameterType.BOOLEAN,
+				description: "Only search in local statuses",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "remote",
+				type: CliParameterType.BOOLEAN,
+				description: "Only search in remote statuses",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "format",
+				type: CliParameterType.STRING,
+				description: "Output format (can be json or csv)",
+				needsValue: true,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+			},
+			{
+				name: "case-sensitive",
+				shortName: "c",
+				type: CliParameterType.EMPTY,
+				description: "Case-sensitive search",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "limit",
+				type: CliParameterType.NUMBER,
+				description: "Limit the number of notes to list (default 20)",
+				needsValue: true,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "redact",
+				type: CliParameterType.BOOLEAN,
+				description:
+					"Redact sensitive information (such as password hashes, emails or keys)",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const {
+				query,
+				local,
+				remote,
+				format,
+				help,
+				limit = 20,
+				fields = [],
+				"case-sensitive": caseSensitive = false,
+				redact,
+			} = args;
+
+			if (help) {
+				instance.displayHelp();
+				return 0;
+			}
+
+			if (!query) {
+				console.log(`${chalk.red(`✗`)} Missing query parameter`);
+				return 1;
+			}
+
+			if (fields.length === 0) {
+				console.log(`${chalk.red(`✗`)} Missing fields parameter`);
+				return 1;
+			}
+
+			const queries: Prisma.StatusWhereInput[] = [];
+
+			for (const field of fields) {
+				queries.push({
+					[field]: {
+						contains: query,
+						mode: caseSensitive ? "default" : "insensitive",
 					},
 				});
+			}
+
+			let instanceIdQuery;
+
+			if (local && remote) {
+				instanceIdQuery = undefined;
+			} else if (local) {
+				instanceIdQuery = null;
+			} else if (remote) {
+				instanceIdQuery = {
+					not: null,
+				};
+			} else {
+				instanceIdQuery = undefined;
+			}
+
+			const notes = await client.status.findMany({
+				where: {
+					OR: queries,
+					instanceId: instanceIdQuery,
+				},
+				include: {
+					author: true,
+					instance: true,
+				},
+				take: limit,
+			});
+
+			if (redact) {
+				for (const note of notes) {
+					note.author.email = "[REDACTED]";
+					note.author.password = "[REDACTED]";
+					note.author.publicKey = "[REDACTED]";
+					note.author.privateKey = "[REDACTED]";
+				}
+			}
+
+			if (format === "json") {
+				console.log(JSON.stringify(notes, null, 4));
+				return 0;
+			} else if (format === "csv") {
+				const parser = new Parser({});
+				console.log(parser.parse(notes));
+				return 0;
+			}
+
+			console.log(
+				`${chalk.green(`✓`)} Found ${chalk.blue(notes.length)} notes (limit ${limit})`
+			);
+
+			const table = new Table({
+				head: [
+					chalk.white(chalk.bold("ID")),
+					chalk.white(chalk.bold("Content")),
+					chalk.white(chalk.bold("Author")),
+					chalk.white(chalk.bold("Instance")),
+					chalk.white(chalk.bold("Created At")),
+				],
+			});
+
+			for (const note of notes) {
+				table.push([
+					chalk.yellow(note.id),
+					chalk.green(note.content),
+					chalk.blue(note.author.username),
+					chalk.red(
+						note.instanceId ? note.instance?.base_url : "Yes"
+					),
+					chalk.blue(note.createdAt.toISOString()),
+				]);
+			}
+
+			console.log(table.toString());
+
+			return 0;
+		},
+		"Searches for a status",
+		"bun cli note search hello --fields content --local"
+	),
+	new CliCommand<{
+		help: boolean;
+		type: string[];
+	}>(
+		["index", "rebuild"],
+		[
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+			},
+			{
+				name: "type",
+				type: CliParameterType.ARRAY,
+				description:
+					"Type(s) of index(es) to rebuild (can be accounts or statuses)",
+				needsValue: true,
+				positioned: false,
+				optional: true,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const { help, type = [] } = args;
+
+			if (help) {
+				instance.displayHelp();
+				return 0;
+			}
+
+			// Check if Meilisearch is enabled
+			if (!config.meilisearch.enabled) {
+				console.log(`${chalk.red(`✗`)} Meilisearch is not enabled`);
+				return 1;
+			}
+
+			// Check type validity
+			for (const _type of type) {
+				if (
+					!Object.values(MeiliIndexType).includes(
+						_type as MeiliIndexType
+					)
+				) {
+					console.log(
+						`${chalk.red(`✗`)} Invalid index type ${chalk.blue(_type)}`
+					);
+					return 1;
+				}
+			}
+
+			if (type.length === 0) {
+				// Rebuild all indexes
+				await rebuildSearchIndexes(Object.values(MeiliIndexType));
+			} else {
+				await rebuildSearchIndexes(type as MeiliIndexType[]);
+			}
+
+			console.log(`${chalk.green(`✓`)} Rebuilt search indexes`);
+
+			return 0;
+		},
+		"Rebuilds the Meilisearch indexes",
+		"bun cli index rebuild"
+	),
+	new CliCommand<{
+		help: boolean;
+		shortcode: string;
+		url: string;
+		"keep-url": boolean;
+	}>(
+		["emoji", "add"],
+		[
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "shortcode",
+				type: CliParameterType.STRING,
+				description: "Shortcode of the new emoji",
+				needsValue: true,
+				positioned: true,
+			},
+			{
+				name: "url",
+				type: CliParameterType.STRING,
+				description: "URL of the new emoji",
+				needsValue: true,
+				positioned: true,
+			},
+			{
+				name: "keep-url",
+				type: CliParameterType.BOOLEAN,
+				description:
+					"Keep the URL of the emoji instead of uploading the file to object storage",
+				needsValue: false,
+				positioned: false,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const { help, shortcode, url } = args;
+
+			if (help) {
+				instance.displayHelp();
+				return 0;
+			}
+
+			if (!shortcode) {
+				console.log(`${chalk.red(`✗`)} Missing shortcode`);
+				return 1;
+			}
+			if (!url) {
+				console.log(`${chalk.red(`✗`)} Missing URL`);
+				return 1;
+			}
+
+			// Check if shortcode is valid
+			if (!shortcode.match(/^[a-zA-Z0-9-_]+$/)) {
+				console.log(
+					`${chalk.red(`✗`)} Invalid shortcode (must be alphanumeric with dashes and underscores allowed)`
+				);
+				return 1;
+			}
+
+			// Check if URL is valid
+			if (!URL.canParse(url)) {
+				console.log(
+					`${chalk.red(`✗`)} Invalid URL (must be a valid full URL, including protocol)`
+				);
+				return 1;
+			}
+
+			// Check if emoji already exists
+			const existingEmoji = await client.emoji.findFirst({
+				where: {
+					shortcode: shortcode,
+					instanceId: null,
+				},
+			});
+
+			if (existingEmoji) {
+				console.log(
+					`${chalk.red(`✗`)} Emoji with shortcode ${chalk.blue(
+						shortcode
+					)} already exists`
+				);
+				return 1;
+			}
+
+			let newUrl = url;
+
+			if (!args["keep-url"]) {
+				// Upload the emoji to object storage
+				const mediaBackend = await MediaBackend.fromBackendType(
+					config.media.backend,
+					config
+				);
 
 				console.log(
-					`${chalk.green(`✓`)} Deleted user ${chalk.blue(
-						user.username
+					`${chalk.blue(`⏳`)} Downloading emoji from ${chalk.underline(chalk.blue(url))}`
+				);
+
+				const downloadedFile = await fetch(url).then(
+					async r =>
+						new File(
+							[await r.blob()],
+							url.split("/").pop() ??
+								`${crypto.randomUUID()}-emoji.png`
+						)
+				);
+
+				const metadata = await mediaBackend
+					.addFile(downloadedFile)
+					.catch(() => null);
+
+				if (!metadata) {
+					console.log(
+						`${chalk.red(`✗`)} Failed to upload emoji to object storage (is your URL accessible?)`
+					);
+					return 1;
+				}
+
+				newUrl = getUrl(metadata.uploadedFile.name, config);
+
+				console.log(
+					`${chalk.green(`✓`)} Uploaded emoji to object storage`
+				);
+			}
+
+			// Add the emoji
+			const content_type = `image/${url
+				.split(".")
+				.pop()
+				?.replace("jpg", "jpeg")}}`;
+
+			const emoji = await client.emoji.create({
+				data: {
+					shortcode: shortcode,
+					url: newUrl,
+					visible_in_picker: true,
+					content_type: content_type,
+					instanceId: null,
+				},
+			});
+
+			console.log(
+				`${chalk.green(`✓`)} Created emoji ${chalk.blue(
+					emoji.shortcode
+				)}`
+			);
+
+			return 0;
+		},
+		"Adds a custom emoji",
+		"bun cli emoji add bun https://bun.com/bun.png"
+	),
+	new CliCommand<{
+		help: boolean;
+		shortcode: string;
+		noconfirm: boolean;
+	}>(
+		["emoji", "delete"],
+		[
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "shortcode",
+				type: CliParameterType.STRING,
+				description:
+					"Shortcode of the emoji to delete (can add up to two wildcards *)",
+				needsValue: true,
+				positioned: true,
+			},
+			{
+				name: "noconfirm",
+				type: CliParameterType.BOOLEAN,
+				description: "Skip confirmation",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const { help, shortcode, noconfirm } = args;
+
+			if (help) {
+				instance.displayHelp();
+				return 0;
+			}
+
+			if (!shortcode) {
+				console.log(`${chalk.red(`✗`)} Missing shortcode`);
+				return 1;
+			}
+
+			// Check if shortcode is valid
+			if (!shortcode.match(/^[a-zA-Z0-9-_*]+$/)) {
+				console.log(
+					`${chalk.red(`✗`)} Invalid shortcode (must be alphanumeric with dashes and underscores allowed + optional wildcards)`
+				);
+				return 1;
+			}
+
+			// Validate up to one wildcard
+			if (shortcode.split("*").length > 3) {
+				console.log(
+					`${chalk.red(`✗`)} Invalid shortcode (can only have up to two wildcards)`
+				);
+				return 1;
+			}
+
+			const hasWildcard = shortcode.includes("*");
+			const hasTwoWildcards = shortcode.split("*").length === 3;
+
+			const emojis = await client.emoji.findMany({
+				where: {
+					shortcode: {
+						startsWith: hasWildcard
+							? shortcode.split("*")[0]
+							: undefined,
+						endsWith: hasWildcard
+							? shortcode.split("*").at(-1)
+							: undefined,
+						contains: hasTwoWildcards
+							? shortcode.split("*")[1]
+							: undefined,
+						equals: hasWildcard ? undefined : shortcode,
+					},
+					instanceId: null,
+				},
+			});
+
+			if (emojis.length === 0) {
+				console.log(
+					`${chalk.red(`✗`)} No emoji with shortcode ${chalk.blue(
+						shortcode
+					)} found`
+				);
+				return 1;
+			}
+
+			// List emojis and ask for confirmation
+			for (const emoji of emojis) {
+				console.log(
+					`${chalk.blue(emoji.shortcode)}: ${chalk.underline(
+						emoji.url
 					)}`
 				);
-
-				break;
 			}
-			case "list": {
-				const admins = args.includes("--admins");
 
-				const users = await client.user.findMany({
-					where: {
-						isAdmin: admins || undefined,
+			if (!noconfirm) {
+				process.stdout.write(
+					`Are you sure you want to delete these emojis?\n${chalk.red(chalk.bold("This is a destructive action and cannot be undone!"))} [y/N] `
+				);
+
+				for await (const line of console) {
+					if (line.trim().toLowerCase() === "y") {
+						break;
+					} else {
+						console.log(`${chalk.red(`✗`)} Deletion cancelled`);
+						return 0;
+					}
+				}
+			}
+
+			await client.emoji.deleteMany({
+				where: {
+					id: {
+						in: emojis.map(e => e.id),
 					},
-					take: 200,
-				});
+				},
+			});
 
+			console.log(
+				`${chalk.green(`✓`)} Deleted emojis matching shortcode ${chalk.blue(
+					shortcode
+				)}`
+			);
+
+			return 0;
+		},
+		"Deletes custom emojis",
+		"bun cli emoji delete bun"
+	),
+	new CliCommand<{
+		help: boolean;
+		format: string;
+		limit: number;
+	}>(
+		["emoji", "list"],
+		[
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "format",
+				type: CliParameterType.STRING,
+				description: "Output format (can be json or csv)",
+				needsValue: true,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "limit",
+				type: CliParameterType.NUMBER,
+				description: "Limit the number of emojis to list (default 20)",
+				needsValue: true,
+				positioned: false,
+				optional: true,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const { help, format, limit = 20 } = args;
+
+			if (help) {
+				instance.displayHelp();
+				return 0;
+			}
+
+			const emojis = await client.emoji.findMany({
+				where: {
+					instanceId: null,
+				},
+				take: limit,
+			});
+
+			if (format === "json") {
+				console.log(JSON.stringify(emojis, null, 4));
+				return 0;
+			} else if (format === "csv") {
+				const parser = new Parser({});
+				console.log(parser.parse(emojis));
+				return 0;
+			}
+
+			console.log(
+				`${chalk.green(`✓`)} Found ${chalk.blue(emojis.length)} emojis (limit ${limit})`
+			);
+
+			const table = new Table({
+				head: [
+					chalk.white(chalk.bold("Shortcode")),
+					chalk.white(chalk.bold("URL")),
+				],
+			});
+
+			for (const emoji of emojis) {
+				table.push([
+					chalk.blue(emoji.shortcode),
+					chalk.underline(emoji.url),
+				]);
+			}
+
+			console.log(table.toString());
+
+			return 0;
+		},
+		"Lists all custom emojis",
+		"bun cli emoji list"
+	),
+	new CliCommand<{
+		help: boolean;
+		url: string;
+		noconfirm: boolean;
+	}>(
+		["emoji", "import"],
+		[
+			{
+				name: "help",
+				shortName: "h",
+				type: CliParameterType.EMPTY,
+				description: "Show help message",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+			{
+				name: "url",
+				type: CliParameterType.STRING,
+				description: "URL of the emoji pack manifest",
+				needsValue: true,
+				positioned: true,
+			},
+			{
+				name: "noconfirm",
+				type: CliParameterType.BOOLEAN,
+				description: "Skip confirmation",
+				needsValue: false,
+				positioned: false,
+				optional: true,
+			},
+		],
+		async (instance: CliCommand, args) => {
+			const { help, url, noconfirm } = args;
+
+			if (help) {
+				instance.displayHelp();
+				return 0;
+			}
+
+			if (!url) {
+				console.log(`${chalk.red(`✗`)} Missing URL`);
+				return 1;
+			}
+
+			// Check if URL is valid
+			if (!URL.canParse(url)) {
 				console.log(
-					`${chalk.green(`✓`)} Found ${chalk.blue(
-						users.length
-					)} users`
+					`${chalk.red(`✗`)} Invalid URL (must be a valid full URL, including protocol)`
 				);
-
-				for (const user of users) {
-					console.log(
-						`\t${chalk.blue(user.username)} ${chalk.gray(
-							user.email
-						)} ${chalk.green(user.isAdmin ? "Admin" : "User")}`
-					);
-				}
-				break;
+				return 1;
 			}
-			case "search": {
-				const argsWithoutFlags = args.filter(
-					arg => !arg.startsWith("--")
+
+			// Fetch the emoji pack manifest
+			const manifest = await fetch(url)
+				.then(
+					r =>
+						r.json() as Promise<
+							Record<
+								string,
+								{
+									files: string;
+									homepage: string;
+									src: string;
+									src_sha256?: string;
+								}
+							>
+						>
+				)
+				.catch(() => null);
+
+			if (!manifest) {
+				console.log(
+					`${chalk.red(`✗`)} Failed to fetch emoji pack manifest from ${chalk.underline(
+						url
+					)}`
 				);
-				const query = argsWithoutFlags[4];
+				return 1;
+			}
 
-				if (!query) {
-					console.log(`${chalk.red(`✗`)} Missing query`);
-					process.exit(1);
-				}
+			const homepage = Object.values(manifest)[0].homepage;
+			// If URL is not a valid URL, assume it's a relative path to homepage
+			const srcUrl = URL.canParse(Object.values(manifest)[0].src)
+				? Object.values(manifest)[0].src
+				: new URL(Object.values(manifest)[0].src, homepage).toString();
+			const filesUrl = URL.canParse(Object.values(manifest)[0].files)
+				? Object.values(manifest)[0].files
+				: new URL(
+						Object.values(manifest)[0].files,
+						homepage
+					).toString();
 
-				const displayname = args.includes("--displayname");
-				const bio = args.includes("--bio");
-				const local = args.includes("--local");
-				const remote = args.includes("--remote");
-				const email = args.includes("--email");
-				const json = args.includes("--json");
-				const csv = args.includes("--csv");
+			console.log(
+				`${chalk.blue(`⏳`)} Fetching emoji pack from ${chalk.underline(
+					srcUrl
+				)}`
+			);
 
-				const queries: Prisma.UserWhereInput[] = [];
+			// Fetch actual pack (should be a zip file)
+			const pack = await fetch(srcUrl)
+				.then(
+					async r =>
+						new File(
+							[await r.blob()],
+							srcUrl.split("/").pop() ?? "pack.zip"
+						)
+				)
+				.catch(() => null);
 
-				if (displayname) {
-					queries.push({
-						displayName: {
-							contains: query,
-							mode: "insensitive",
-						},
-					});
-				}
+			// Check if pack is valid
+			if (!pack) {
+				console.log(
+					`${chalk.red(`✗`)} Failed to fetch emoji pack from ${chalk.underline(
+						srcUrl
+					)}`
+				);
+				return 1;
+			}
 
-				if (bio) {
-					queries.push({
-						note: {
-							contains: query,
-							mode: "insensitive",
-						},
-					});
-				}
-
-				if (local) {
-					queries.push({
-						instanceId: null,
-					});
-				}
-
-				if (remote) {
-					queries.push({
-						instanceId: {
-							not: null,
-						},
-					});
-				}
-
-				if (email) {
-					queries.push({
-						email: {
-							contains: query,
-							mode: "insensitive",
-						},
-					});
-				}
-
-				const users = await client.user.findMany({
-					where: {
-						AND: queries,
-					},
-					include: {
-						instance: true,
-					},
-					take: 40,
-				});
-
-				if (json || csv) {
-					if (json) {
-						console.log(JSON.stringify(users, null, 4));
-					}
-					if (csv) {
-						// Convert the outputted JSON to CSV
-
-						// Remove all object children from each object
-						const items = users.map(user => {
-							const item = {
-								...user,
-								instance: undefined,
-								endpoints: undefined,
-								source: undefined,
-							};
-							return item;
-						});
-						const replacer = (key: string, value: any): any =>
-							value === null ? "" : value; // Null values are returned as empty strings
-						const header = Object.keys(items[0]);
-						const csv = [
-							header.join(","), // header row first
-							...items.map(row =>
-								header
-									.map(fieldName =>
-										// @ts-expect-error This is fine
-										JSON.stringify(row[fieldName], replacer)
-									)
-									.join(",")
-							),
-						].join("\r\n");
-
-						console.log(csv);
-					}
+			// Validate sha256 if available
+			if (Object.values(manifest)[0].src_sha256) {
+				const sha256 = new Bun.SHA256()
+					.update(await pack.arrayBuffer())
+					.digest("hex");
+				if (sha256 !== Object.values(manifest)[0].src_sha256) {
+					console.log(
+						`${chalk.red(`✗`)} SHA256 of pack (${chalk.blue(
+							sha256
+						)}) does not match manifest ${chalk.blue(
+							Object.values(manifest)[0].src_sha256
+						)}`
+					);
+					return 1;
 				} else {
 					console.log(
-						`${chalk.green(`✓`)} Found ${chalk.blue(
-							users.length
-						)} users`
+						`${chalk.green(`✓`)} SHA256 of pack matches manifest`
 					);
-
-					const table = new Table({
-						head: [
-							chalk.white(chalk.bold("Username")),
-							chalk.white(chalk.bold("Email")),
-							chalk.white(chalk.bold("Display Name")),
-							chalk.white(chalk.bold("Admin?")),
-							chalk.white(chalk.bold("Instance URL")),
-						],
-					});
-
-					for (const user of users) {
-						table.push([
-							chalk.yellow(`@${user.username}`),
-							chalk.green(user.email),
-							chalk.blue(user.displayName),
-							chalk.red(user.isAdmin ? "Yes" : "No"),
-							chalk.blue(
-								user.instanceId
-									? user.instance?.base_url
-									: "Local"
-							),
-						]);
-					}
-
-					console.log(table.toString());
 				}
-
-				break;
-			}
-			default:
-				console.log(`Unknown command ${chalk.blue(command)}`);
-				break;
-		}
-		break;
-	case "note": {
-		switch (args[3]) {
-			case "delete": {
-				const id = args[4];
-
-				if (!id) {
-					console.log(`${chalk.red(`✗`)} Missing ID`);
-					process.exit(1);
-				}
-
-				const note = await client.status.findFirst({
-					where: {
-						id: id,
-					},
-				});
-
-				if (!note) {
-					console.log(`${chalk.red(`✗`)} Note not found`);
-					process.exit(1);
-				}
-
-				await client.status.delete({
-					where: {
-						id: note.id,
-					},
-				});
-
+			} else {
 				console.log(
-					`${chalk.green(`✓`)} Deleted note ${chalk.blue(note.id)}`
+					`${chalk.yellow(`⚠`)} No SHA256 in manifest, skipping validation`
 				);
-
-				break;
 			}
-			case "search": {
-				const argsWithoutFlags = args.filter(
-					arg => !arg.startsWith("--")
+
+			console.log(
+				`${chalk.green(`✓`)} Fetched emoji pack from ${chalk.underline(srcUrl)}, unzipping to tempdir`
+			);
+
+			// Unzip the pack to temp dir
+			const tempDir = await mkdtemp(join(tmpdir(), "bun-emoji-import-"));
+
+			console.log(join(tempDir, pack.name));
+
+			// Put the pack as a file
+			await Bun.write(join(tempDir, pack.name), pack);
+
+			await extract(join(tempDir, pack.name), {
+				dir: tempDir,
+			});
+
+			console.log(
+				`${chalk.green(`✓`)} Unzipped emoji pack to ${chalk.blue(tempDir)}`
+			);
+
+			console.log(
+				`${chalk.blue(`⏳`)} Fetching emoji pack file metadata from ${chalk.underline(
+					filesUrl
+				)}`
+			);
+
+			// Fetch files URL
+			const packFiles = await fetch(filesUrl)
+				.then(r => r.json() as Promise<Record<string, string>>)
+				.catch(() => null);
+
+			if (!packFiles) {
+				console.log(
+					`${chalk.red(`✗`)} Failed to fetch emoji pack file metadata from ${chalk.underline(
+						filesUrl
+					)}`
 				);
-				const query = argsWithoutFlags[4];
+				return 1;
+			}
 
-				if (!query) {
-					console.log(`${chalk.red(`✗`)} Missing query`);
-					process.exit(1);
+			console.log(
+				`${chalk.green(`✓`)} Fetched emoji pack file metadata from ${chalk.underline(
+					filesUrl
+				)}`
+			);
+
+			if (Object.keys(packFiles).length === 0) {
+				console.log(`${chalk.red(`✗`)} Empty emoji pack`);
+				return 1;
+			}
+
+			if (!noconfirm) {
+				process.stdout.write(
+					`Are you sure you want to import ${chalk.blue(
+						Object.keys(packFiles).length
+					)} emojis from ${chalk.underline(chalk.blue(url))}? [y/N] `
+				);
+
+				for await (const line of console) {
+					if (line.trim().toLowerCase() === "y") {
+						break;
+					} else {
+						console.log(`${chalk.red(`✗`)} Import cancelled`);
+						return 0;
+					}
 				}
+			}
 
-				const local = args.includes("--local");
-				const remote = args.includes("--remote");
-				const json = args.includes("--json");
-				const csv = args.includes("--csv");
+			const successfullyImported: string[] = [];
 
-				const queries: Prisma.StatusWhereInput[] = [];
+			// Add emojis
+			for (const [shortcode, url] of Object.entries(packFiles)) {
+				// If emoji URL is not a valid URL, assume it's a relative path to homepage
+				const fileUrl = Bun.pathToFileURL(
+					join(tempDir, url)
+				).toString();
 
-				if (local) {
-					queries.push({
-						instanceId: null,
-					});
-				}
-
-				if (remote) {
-					queries.push({
-						instanceId: {
-							not: null,
-						},
-					});
-				}
-
-				const statuses = await client.status.findMany({
+				// Check if emoji already exists
+				const existingEmoji = await client.emoji.findFirst({
 					where: {
-						AND: queries,
-						content: {
-							contains: query,
-							mode: "insensitive",
-						},
-					},
-					take: 40,
-					include: {
-						author: true,
-						instance: true,
+						shortcode: shortcode,
+						instanceId: null,
 					},
 				});
 
-				if (json || csv) {
-					if (json) {
-						console.log(JSON.stringify(statuses, null, 4));
-					}
-					if (csv) {
-						// Convert the outputted JSON to CSV
-
-						// Remove all object children from each object
-						const items = statuses.map(status => {
-							const item = {
-								...status,
-								author: undefined,
-								instance: undefined,
-							};
-							return item;
-						});
-						const replacer = (key: string, value: any): any =>
-							value === null ? "" : value; // Null values are returned as empty strings
-						const header = Object.keys(items[0]);
-						const csv = [
-							header.join(","), // header row first
-							...items.map(row =>
-								header
-									.map(fieldName =>
-										// @ts-expect-error This is fine
-										JSON.stringify(row[fieldName], replacer)
-									)
-									.join(",")
-							),
-						].join("\r\n");
-
-						console.log(csv);
-					}
-				} else {
+				if (existingEmoji) {
 					console.log(
-						`${chalk.green(`✓`)} Found ${chalk.blue(
-							statuses.length
-						)} statuses`
+						`${chalk.red(`✗`)} Emoji with shortcode ${chalk.blue(
+							shortcode
+						)} already exists`
 					);
-
-					const table = new Table({
-						head: [
-							chalk.white(chalk.bold("Username")),
-							chalk.white(chalk.bold("Instance URL")),
-							chalk.white(chalk.bold("Content")),
-						],
-					});
-
-					for (const status of statuses) {
-						table.push([
-							chalk.yellow(`@${status.author.username}`),
-							chalk.blue(
-								status.instanceId
-									? status.instance?.base_url
-									: "Local"
-							),
-							chalk.green(status.content.slice(0, 50)),
-						]);
-					}
-
-					console.log(table.toString());
+					continue;
 				}
 
-				break;
-			}
-			default:
-				console.log(`Unknown command ${chalk.blue(command)}`);
-				break;
-		}
+				// Add the emoji by calling the add command
+				const returnCode = await cliBuilder.processArgs([
+					"emoji",
+					"add",
+					shortcode,
+					fileUrl,
+					"--noconfirm",
+				]);
 
-		break;
-	}
-	default:
-		console.log(`Unknown command ${chalk.blue(command)}`);
-		break;
-}
+				if (returnCode === 0) successfullyImported.push(shortcode);
+			}
+
+			console.log(
+				`${chalk.green(`✓`)} Imported ${successfullyImported.length} emojis from ${chalk.underline(
+					url
+				)}`
+			);
+
+			// List imported
+			if (successfullyImported.length > 0) {
+				console.log(
+					`${chalk.green(`✓`)} Successfully imported ${successfullyImported.length} emojis: ${successfullyImported.join(
+						", "
+					)}`
+				);
+			}
+
+			// List unimported
+			if (successfullyImported.length < Object.keys(packFiles).length) {
+				const unimported = Object.keys(packFiles).filter(
+					key => !successfullyImported.includes(key)
+				);
+				console.log(
+					`${chalk.red(`✗`)} Failed to import ${unimported.length} emojis: ${unimported.join(
+						", "
+					)}`
+				);
+			}
+
+			return 0;
+		},
+		"Imports a Pleroma emoji pack",
+		"bun cli emoji import https://site.com/neofox/manifest.json"
+	),
+]);
+
+// eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+const exitCode = await cliBuilder.processArgs(args);
+
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+process.exit(Number(exitCode ?? 0));
diff --git a/config/config.example.toml b/config/config.example.toml
index 603eb05a..de256901 100644
--- a/config/config.example.toml
+++ b/config/config.example.toml
@@ -18,6 +18,36 @@ password = ""
 database = 1
 enabled = false
 
+[meilisearch]
+host = "localhost"
+port = 40007
+api_key = ""
+enabled = true
+
+[signups]
+# URL of your Terms of Service
+tos_url = "https://example.com/tos"
+# Whether to enable registrations or not
+registration = true
+rules = [
+	"Do not harass others",
+	"Be nice to people",
+	"Don't spam",
+	"Don't post illegal content",
+]
+
+# Delete this section if you don't want to use custom OAuth providers
+# This is an example configuration
+# The provider MUST support OpenID Connect with .well-known discovery
+# Most notably, GitHub does not support this
+[[oidc.providers]]
+name = "CPlusPatch ID"
+id = "cpluspatch-id"
+url = "https://id.cpluspatch.com/application/o/lysand-testing/"
+client_id = "XXXXXXXXXXXXXXXX"
+client_secret = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+icon = "https://cpluspatch.com/images/icons/logo.svg"
+
 [http]
 base_url = "https://lysand.social"
 bind = "http://localhost"
@@ -41,6 +71,8 @@ tls = true
 backend = "s3"
 # Whether to check the hash of media when uploading to avoid duplication
 deduplicate_media = true
+# If media backend is "local", this is the folder where the files will be stored
+local_uploads_folder = "uploads"
 
 [media.conversion]
 convert_images = false
@@ -240,6 +272,8 @@ emoji_filters = [] # NOT IMPLEMENTED
 log_requests = true
 # Log request and their contents (warning: this is a lot of data)
 log_requests_verbose = false
+# For GDPR compliance, you can disable logging of IPs
+log_ip = false
 
 # Log all filtered objects
 log_filters = true
diff --git a/database/datasource.ts b/database/datasource.ts
index b2a1e23a..334d2d58 100644
--- a/database/datasource.ts
+++ b/database/datasource.ts
@@ -1,8 +1,8 @@
 import { Queue } from "bullmq";
-import { getConfig } from "../utils/config";
 import { PrismaClient } from "@prisma/client";
+import { ConfigManager } from "config-manager";
 
-const config = getConfig();
+const config = await new ConfigManager({}).getConfig();
 
 const client = new PrismaClient({
 	datasourceUrl: `postgresql://${config.database.username}:${config.database.password}@${config.database.host}:${config.database.port}/${config.database.database}`,
diff --git a/database/entities/Attachment.ts b/database/entities/Attachment.ts
index e85bdeac..abb07c9e 100644
--- a/database/entities/Attachment.ts
+++ b/database/entities/Attachment.ts
@@ -1,5 +1,6 @@
-import type { ConfigType } from "@config";
 import type { Attachment } from "@prisma/client";
+import type { ConfigType } from "config-manager";
+import { MediaBackendType } from "media-manager";
 import type { APIAsyncAttachment } from "~types/entities/async_attachment";
 import type { APIAttachment } from "~types/entities/attachment";
 
@@ -56,11 +57,13 @@ export const attachmentToAPI = (
 	};
 };
 
-export const getUrl = (hash: string, config: ConfigType) => {
-	if (config.media.backend === "local") {
-		return `${config.http.base_url}/media/${hash}`;
-	} else if (config.media.backend === "s3") {
-		return `${config.s3.public_url}/${hash}`;
+export const getUrl = (name: string, config: ConfigType) => {
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+	if (config.media.backend === MediaBackendType.LOCAL) {
+		return `${config.http.base_url}/media/${name}`;
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+	} else if (config.media.backend === MediaBackendType.S3) {
+		return `${config.s3.public_url}/${name}`;
 	}
 	return "";
 };
diff --git a/database/entities/Emoji.ts b/database/entities/Emoji.ts
index 55511503..5a610fc4 100644
--- a/database/entities/Emoji.ts
+++ b/database/entities/Emoji.ts
@@ -76,3 +76,22 @@ export const emojiToLysand = (emoji: Emoji): LysandEmoji => {
 		alt: emoji.alt || undefined,
 	};
 };
+
+/**
+ * Converts the emoji to an ActivityPub object.
+ * @returns The ActivityPub object.
+ */
+export const emojiToActivityPub = (emoji: Emoji): any => {
+	// replace any with your ActivityPub Emoji type
+	return {
+		type: "Emoji",
+		name: `:${emoji.shortcode}:`,
+		updated: new Date().toISOString(),
+		icon: {
+			type: "Image",
+			url: emoji.url,
+			mediaType: emoji.content_type,
+			alt: emoji.alt || undefined,
+		},
+	};
+};
diff --git a/database/entities/Like.ts b/database/entities/Like.ts
index f4dbf482..037fd547 100644
--- a/database/entities/Like.ts
+++ b/database/entities/Like.ts
@@ -1,10 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import type { Like as LysandLike } from "~types/lysand/Object";
-import { getConfig } from "@config";
 import type { Like } from "@prisma/client";
 import { client } from "~database/datasource";
 import type { UserWithRelations } from "./User";
 import type { StatusWithRelations } from "./Status";
+import { ConfigManager } from "config-manager";
+
+const config = await new ConfigManager({}).getConfig();
 
 /**
  * Represents a Like entity in the database.
@@ -16,7 +18,7 @@ export const toLysand = (like: Like): LysandLike => {
 		type: "Like",
 		created_at: new Date(like.createdAt).toISOString(),
 		object: (like as any).liked?.uri,
-		uri: `${getConfig().http.base_url}/actions/${like.id}`,
+		uri: `${config.http.base_url}/actions/${like.id}`,
 	};
 };
 
diff --git a/database/entities/Notification.ts b/database/entities/Notification.ts
index f6bd4c00..80399f30 100644
--- a/database/entities/Notification.ts
+++ b/database/entities/Notification.ts
@@ -13,7 +13,7 @@ export const notificationToAPI = async (
 ): Promise<APINotification> => {
 	return {
 		account: userToAPI(notification.account),
-		created_at: notification.createdAt.toISOString(),
+		created_at: new Date(notification.createdAt).toISOString(),
 		id: notification.id,
 		type: notification.type,
 		status: notification.status
diff --git a/database/entities/Queue.ts b/database/entities/Queue.ts
index 5e3e1d01..9364497e 100644
--- a/database/entities/Queue.ts
+++ b/database/entities/Queue.ts
@@ -1,4 +1,3 @@
-import { getConfig } from "@config";
 import { Worker } from "bullmq";
 import { client, federationQueue } from "~database/datasource";
 import {
@@ -7,8 +6,9 @@ import {
 	type StatusWithRelations,
 } from "./Status";
 import type { User } from "@prisma/client";
+import { ConfigManager } from "config-manager";
 
-const config = getConfig();
+const config = await new ConfigManager({}).getConfig();
 
 export const federationWorker = new Worker(
 	"federation",
@@ -44,7 +44,7 @@ export const federationWorker = new Worker(
 										instanceId: {
 											not: null,
 										},
-								  }
+									}
 								: {},
 							// Mentioned users
 							{
diff --git a/database/entities/Status.ts b/database/entities/Status.ts
index 4b1cd2a8..b3ff0d6c 100644
--- a/database/entities/Status.ts
+++ b/database/entities/Status.ts
@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { getConfig } from "@config";
 import type { UserWithRelations } from "./User";
 import {
 	fetchRemoteUser,
@@ -24,8 +23,14 @@ import type { APIStatus } from "~types/entities/status";
 import { applicationToAPI } from "./Application";
 import { attachmentToAPI } from "./Attachment";
 import type { APIAttachment } from "~types/entities/attachment";
+import { sanitizeHtml } from "@sanitization";
+import { parse } from "marked";
+import linkifyStr from "linkify-string";
+import linkifyHtml from "linkify-html";
+import { addStausToMeilisearch } from "@meilisearch";
+import { ConfigManager } from "config-manager";
 
-const config = getConfig();
+const config = await new ConfigManager({}).getConfig();
 
 export const statusAndUserRelations: Prisma.StatusInclude = {
 	author: {
@@ -206,7 +211,7 @@ export const fetchFromRemote = async (uri: string): Promise<Status | null> => {
 			? {
 					status: replyStatus,
 					user: (replyStatus as any).author,
-			  }
+				}
 			: undefined,
 		quote: quotingStatus || undefined,
 	});
@@ -303,7 +308,7 @@ export const createNewStatus = async (data: {
 	visibility: APIStatus["visibility"];
 	sensitive: boolean;
 	spoiler_text: string;
-	emojis: Emoji[];
+	emojis?: Emoji[];
 	content_type?: string;
 	uri?: string;
 	mentions?: User[];
@@ -320,6 +325,11 @@ export const createNewStatus = async (data: {
 
 	let mentions = data.mentions || [];
 
+	// Parse emojis
+	const emojis = await parseEmojis(data.content);
+
+	data.emojis = data.emojis ? [...data.emojis, ...emojis] : emojis;
+
 	// Get list of mentioned users
 	if (mentions.length === 0) {
 		mentions = await client.user.findMany({
@@ -335,11 +345,32 @@ export const createNewStatus = async (data: {
 		});
 	}
 
+	let formattedContent;
+
+	// Get HTML version of content
+	if (data.content_type === "text/markdown") {
+		formattedContent = linkifyHtml(
+			await sanitizeHtml(await parse(data.content))
+		);
+	} else if (data.content_type === "text/x.misskeymarkdown") {
+		// Parse as MFM
+	} else {
+		// Parse as plaintext
+		formattedContent = linkifyStr(data.content);
+
+		// Split by newline and add <p> tags
+		formattedContent = formattedContent
+			.split("\n")
+			.map(line => `<p>${line}</p>`)
+			.join("\n");
+	}
+
 	let status = await client.status.create({
 		data: {
 			authorId: data.account.id,
 			applicationId: data.application?.id,
-			content: data.content,
+			content: formattedContent,
+			contentSource: data.content,
 			contentType: data.content_type,
 			visibility: data.visibility,
 			sensitive: data.sensitive,
@@ -358,7 +389,7 @@ export const createNewStatus = async (data: {
 								id: attachment,
 							};
 						}),
-				  }
+					}
 				: undefined,
 			inReplyToPostId: data.reply?.status.id,
 			quotingPostId: data.quote?.id,
@@ -390,7 +421,6 @@ export const createNewStatus = async (data: {
 	});
 
 	// Create notification
-
 	if (status.inReplyToPost) {
 		await client.notification.create({
 			data: {
@@ -402,9 +432,113 @@ export const createNewStatus = async (data: {
 		});
 	}
 
+	// Add to search index
+	await addStausToMeilisearch(status);
+
 	return status;
 };
 
+export const editStatus = async (
+	status: StatusWithRelations,
+	data: {
+		content: string;
+		visibility?: APIStatus["visibility"];
+		sensitive: boolean;
+		spoiler_text: string;
+		emojis?: Emoji[];
+		content_type?: string;
+		uri?: string;
+		mentions?: User[];
+		media_attachments?: string[];
+	}
+) => {
+	// Get people mentioned in the content (match @username or @username@domain.com mentions
+	const mentionedPeople =
+		data.content.match(/@[a-zA-Z0-9_]+(@[a-zA-Z0-9_]+)?/g) ?? [];
+
+	let mentions = data.mentions || [];
+
+	// Parse emojis
+	const emojis = await parseEmojis(data.content);
+
+	data.emojis = data.emojis ? [...data.emojis, ...emojis] : emojis;
+
+	// Get list of mentioned users
+	if (mentions.length === 0) {
+		mentions = await client.user.findMany({
+			where: {
+				OR: mentionedPeople.map(person => ({
+					username: person.split("@")[1],
+					instance: {
+						base_url: person.split("@")[2],
+					},
+				})),
+			},
+			include: userRelations,
+		});
+	}
+
+	let formattedContent;
+
+	// Get HTML version of content
+	if (data.content_type === "text/markdown") {
+		formattedContent = linkifyHtml(
+			await sanitizeHtml(await parse(data.content))
+		);
+	} else if (data.content_type === "text/x.misskeymarkdown") {
+		// Parse as MFM
+	} else {
+		// Parse as plaintext
+		formattedContent = linkifyStr(data.content);
+
+		// Split by newline and add <p> tags
+		formattedContent = formattedContent
+			.split("\n")
+			.map(line => `<p>${line}</p>`)
+			.join("\n");
+	}
+
+	const newStatus = await client.status.update({
+		where: {
+			id: status.id,
+		},
+		data: {
+			content: formattedContent,
+			contentSource: data.content,
+			contentType: data.content_type,
+			visibility: data.visibility,
+			sensitive: data.sensitive,
+			spoilerText: data.spoiler_text,
+			emojis: {
+				connect: data.emojis.map(emoji => {
+					return {
+						id: emoji.id,
+					};
+				}),
+			},
+			attachments: data.media_attachments
+				? {
+						connect: data.media_attachments.map(attachment => {
+							return {
+								id: attachment,
+							};
+						}),
+					}
+				: undefined,
+			mentions: {
+				connect: mentions.map(mention => {
+					return {
+						id: mention.id,
+					};
+				}),
+			},
+		},
+		include: statusAndUserRelations,
+	});
+
+	return newStatus;
+};
+
 export const isFavouritedBy = async (status: Status, user: User) => {
 	return !!(await client.like.findFirst({
 		where: {
@@ -476,12 +610,59 @@ export const statusToAPI = async (
 		quote: status.quotingPost
 			? await statusToAPI(
 					status.quotingPost as unknown as StatusWithRelations
-			  )
+				)
 			: null,
 		quote_id: status.quotingPost?.id || undefined,
 	};
 };
 
+/* export const statusToActivityPub = async (
+	status: StatusWithRelations
+	// user?: UserWithRelations
+): Promise<any> => {
+	// replace any with your ActivityPub type
+	return {
+		"@context": [
+			"https://www.w3.org/ns/activitystreams",
+			"https://mastodon.social/schemas/litepub-0.1.jsonld",
+		],
+		id: `${config.http.base_url}/users/${status.authorId}/statuses/${status.id}`,
+		type: "Note",
+		summary: status.spoilerText,
+		content: status.content,
+		published: new Date(status.createdAt).toISOString(),
+		url: `${config.http.base_url}/users/${status.authorId}/statuses/${status.id}`,
+		attributedTo: `${config.http.base_url}/users/${status.authorId}`,
+		to: ["https://www.w3.org/ns/activitystreams#Public"],
+		cc: [], // add recipients here
+		sensitive: status.sensitive,
+		attachment: (status.attachments ?? []).map(
+			a => attachmentToActivityPub(a) as ActivityPubAttachment // replace with your function
+		),
+		tag: [], // add tags here
+		replies: {
+			id: `${config.http.base_url}/users/${status.authorId}/statuses/${status.id}/replies`,
+			type: "Collection",
+			totalItems: status._count.replies,
+		},
+		likes: {
+			id: `${config.http.base_url}/users/${status.authorId}/statuses/${status.id}/likes`,
+			type: "Collection",
+			totalItems: status._count.likes,
+		},
+		shares: {
+			id: `${config.http.base_url}/users/${status.authorId}/statuses/${status.id}/shares`,
+			type: "Collection",
+			totalItems: status._count.reblogs,
+		},
+		inReplyTo: status.inReplyToPostId
+			? `${config.http.base_url}/users/${status.inReplyToPost?.authorId}/statuses/${status.inReplyToPostId}`
+			: null,
+		visibility: "public", // adjust as needed
+		// add more fields as needed
+	};
+}; */
+
 export const statusToLysand = (status: StatusWithRelations): Note => {
 	return {
 		type: "Note",
diff --git a/database/entities/User.ts b/database/entities/User.ts
index 6c781fb6..744c1767 100644
--- a/database/entities/User.ts
+++ b/database/entities/User.ts
@@ -1,5 +1,3 @@
-import type { ConfigType } from "@config";
-import { getConfig } from "@config";
 import type { APIAccount } from "~types/entities/account";
 import type { User as LysandUser } from "~types/lysand/Object";
 import { htmlToText } from "html-to-text";
@@ -9,6 +7,11 @@ import { client } from "~database/datasource";
 import { addEmojiIfNotExists, emojiToAPI, emojiToLysand } from "./Emoji";
 import { addInstanceIfNotExists } from "./Instance";
 import type { APISource } from "~types/entities/source";
+import { addUserToMeilisearch } from "@meilisearch";
+import { ConfigManager, type ConfigType } from "config-manager";
+
+const configManager = new ConfigManager({});
+const config = await configManager.getConfig();
 
 export interface AuthData {
 	user: UserWithRelations | null;
@@ -151,6 +154,9 @@ export const fetchRemoteUser = async (uri: string) => {
 		},
 	});
 
+	// Add to Meilisearch
+	await addUserToMeilisearch(user);
+
 	const emojis = [];
 
 	for (const emoji of userEmojis) {
@@ -197,7 +203,7 @@ export const createNewLocalUser = async (data: {
 	header?: string;
 	admin?: boolean;
 }) => {
-	const config = getConfig();
+	const config = await configManager.getConfig();
 
 	const keys = await generateUserKeys();
 
@@ -224,6 +230,9 @@ export const createNewLocalUser = async (data: {
 		},
 	});
 
+	// Add to Meilisearch
+	await addUserToMeilisearch(user);
+
 	return await client.user.update({
 		where: {
 			id: user.id,
@@ -303,10 +312,10 @@ export const getRelationshipToOtherUser = async (
  * Generates keys for the user.
  */
 export const generateUserKeys = async () => {
-	const keys = (await crypto.subtle.generateKey("Ed25519", true, [
+	const keys = await crypto.subtle.generateKey("Ed25519", true, [
 		"sign",
 		"verify",
-	])) as CryptoKeyPair;
+	]);
 
 	const privateKey = btoa(
 		String.fromCharCode.apply(null, [
@@ -337,8 +346,6 @@ export const userToAPI = (
 	user: UserWithRelations,
 	isOwnAccount = false
 ): APIAccount => {
-	const config = getConfig();
-
 	return {
 		id: user.id,
 		username: user.username,
@@ -366,7 +373,7 @@ export const userToAPI = (
 		header_static: "",
 		acct:
 			user.instance === null
-				? `${user.username}`
+				? user.username
 				: `${user.username}@${user.instance.base_url}`,
 		// TODO: Add these fields
 		limited: false,
@@ -417,13 +424,13 @@ export const userToLysand = (user: UserWithRelations): LysandUser => {
 		username: user.username,
 		avatar: [
 			{
-				content: getAvatarUrl(user, getConfig()) || "",
+				content: getAvatarUrl(user, config) || "",
 				content_type: `image/${user.avatar.split(".")[1]}`,
 			},
 		],
 		header: [
 			{
-				content: getHeaderUrl(user, getConfig()) || "",
+				content: getHeaderUrl(user, config) || "",
 				content_type: `image/${user.header.split(".")[1]}`,
 			},
 		],
@@ -451,7 +458,7 @@ export const userToLysand = (user: UserWithRelations): LysandUser => {
 			],
 		})),
 		public_key: {
-			actor: `${getConfig().http.base_url}/users/${user.id}`,
+			actor: `${config.http.base_url}/users/${user.id}`,
 			public_key: user.publicKey,
 		},
 		extensions: {
diff --git a/docker-compose.yml b/docker-compose.yml
index e8100507..4e66749e 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -35,6 +35,18 @@ services:
         restart: unless-stopped
         networks:
             - lysand-net
+    meilisearch:
+        stdin_open: true
+        environment:
+            - MEILI_MASTER_KEY=add_your_key_here
+        tty: true
+        networks:
+            - lysand-net
+        volumes:
+            - ./meili-data:/meili_data
+        image: getmeili/meilisearch:v1.5
+        container_name: lysand-meilisearch
+        restart: unless-stopped
 
 networks:
     lysand-net:
diff --git a/entrypoint.sh b/entrypoint.sh
new file mode 100755
index 00000000..04964561
--- /dev/null
+++ b/entrypoint.sh
@@ -0,0 +1,37 @@
+#!/bin/sh
+
+# This script is a wrapper for the main server, CLI and Prisma binaries.
+# Commands:
+# - `start`: Starts the server
+# - `cli`: Starts the CLI, sends all arguments to it
+# - `prisma`: Execute a Prisma command, sends 
+
+# Exit immediately if a command exits with a non-zero status.
+set -e
+
+# Parse first argument
+case "$1" in
+  "start")
+    # Start the server
+    exec bun run ./dist/index.js --prod
+    ;;
+  "cli")
+    # Start the CLI
+    shift 1
+    exec bun run ./dist/cli.js "$@"
+    ;;
+  "prisma")
+    # Proxy all Prisma commands
+    # Use output of dist/prisma.js to get the env variable
+    shift 1
+    # Set DATABASE_URL env variable to the output of bun run ./dist/prisma.js
+    export DATABASE_URL=$(bun run ./dist/prisma.js)
+    # Execute the Prisma binary
+    exec bunx prisma "$@"
+    ;;
+  *)
+    # Run custom commands
+    exec "$@"
+    ;;
+esac
+```
\ No newline at end of file
diff --git a/index.ts b/index.ts
index 38a9de04..b3c79055 100644
--- a/index.ts
+++ b/index.ts
@@ -1,41 +1,38 @@
-import { getConfig } from "@config";
-import { jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
-import chalk from "chalk";
-import { appendFile } from "fs/promises";
-import { matches } from "ip-matching";
-import type { AuthData } from "~database/entities/User";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
-import { mkdir } from "fs/promises";
-import { client } from "~database/datasource";
 import type { PrismaClientInitializationError } from "@prisma/client/runtime/library";
-import { HookTypes, Server } from "~plugins/types";
 import { initializeRedisCache } from "@redis";
+import { connectMeili } from "@meilisearch";
+import { ConfigManager } from "config-manager";
+import { client } from "~database/datasource";
+import { LogLevel, LogManager, MultiLogManager } from "log-manager";
+import { moduleIsEntry } from "@module";
+import { createServer } from "~server";
 
 const timeAtStart = performance.now();
-const server = new Server();
 
-const router = new Bun.FileSystemRouter({
-	style: "nextjs",
-	dir: process.cwd() + "/server/api",
-});
+const configManager = new ConfigManager({});
+const config = await configManager.getConfig();
 
-console.log(`${chalk.green(`>`)} ${chalk.bold("Starting Lysand...")}`);
-
-server.emit(HookTypes.PreServe);
-
-const config = getConfig();
 const requests_log = Bun.file(process.cwd() + "/logs/requests.log");
+const isEntry = moduleIsEntry(import.meta.url);
+// If imported as a module, redirect logs to /dev/null to not pollute console (e.g. in tests)
+const logger = new LogManager(isEntry ? requests_log : Bun.file(`/dev/null`));
+const consoleLogger = new LogManager(
+	isEntry ? Bun.stdout : Bun.file(`/dev/null`)
+);
+const dualLogger = new MultiLogManager([logger, consoleLogger]);
 
-if (!(await requests_log.exists())) {
-	console.log(`${chalk.green(`✓`)} ${chalk.bold("Creating logs folder...")}`);
-	await mkdir(process.cwd() + "/logs");
-	await Bun.write(process.cwd() + "/logs/requests.log", "");
-}
+await dualLogger.log(LogLevel.INFO, "Lysand", "Starting Lysand...");
+
+// NODE_ENV seems to be broken and output `development` even when set to production, so use the flag instead
+const isProd =
+	process.env.NODE_ENV === "production" || process.argv.includes("--prod");
 
 const redisCache = await initializeRedisCache();
 
+if (config.meilisearch.enabled) {
+	await connectMeili(dualLogger);
+}
+
 if (redisCache) {
 	client.$use(redisCache);
 }
@@ -46,154 +43,23 @@ try {
 	postCount = await client.status.count();
 } catch (e) {
 	const error = e as PrismaClientInitializationError;
-	console.error(
-		`${chalk.red(`✗`)} ${chalk.bold(
-			"Error while connecting to database: "
-		)} ${error.message}`
-	);
+	await logger.logError(LogLevel.CRITICAL, "Database", error);
+	await consoleLogger.logError(LogLevel.CRITICAL, "Database", error);
 	process.exit(1);
 }
 
-Bun.serve({
-	port: config.http.bind_port,
-	hostname: config.http.bind || "0.0.0.0", // defaults to "0.0.0.0"
-	async fetch(req) {
-		/* Check for banned IPs */
-		const request_ip = this.requestIP(req)?.address ?? "";
+const server = createServer(config, configManager, dualLogger, isProd);
 
-		for (const ip of config.http.banned_ips) {
-			try {
-				if (matches(ip, request_ip)) {
-					return new Response(undefined, {
-						status: 403,
-						statusText: "Forbidden",
-					});
-				}
-			} catch (e) {
-				console.error(`[-] Error while parsing banned IP "${ip}" `);
-				throw e;
-			}
-		}
-
-		await logRequest(req);
-
-		if (req.method === "OPTIONS") {
-			return jsonResponse({});
-		}
-
-		const matchedRoute = router.match(req);
-
-		if (matchedRoute) {
-			const file: {
-				meta: APIRouteMeta;
-				default: (
-					req: Request,
-					matchedRoute: MatchedRoute,
-					auth: AuthData
-				) => Response | Promise<Response>;
-			} = await import(matchedRoute.filePath);
-
-			const meta = file.meta;
-
-			// Check for allowed requests
-			if (!meta.allowedMethods.includes(req.method as any)) {
-				return new Response(undefined, {
-					status: 405,
-					statusText: `Method not allowed: allowed methods are: ${meta.allowedMethods.join(
-						", "
-					)}`,
-				});
-			}
-
-			// TODO: Check for ratelimits
-
-			const auth = await getFromRequest(req);
-
-			// Check for authentication if required
-			if (meta.auth.required) {
-				if (!auth.user) {
-					return new Response(undefined, {
-						status: 401,
-						statusText: "Unauthorized",
-					});
-				}
-			} else if (
-				(meta.auth.requiredOnMethods ?? []).includes(req.method as any)
-			) {
-				if (!auth.user) {
-					return new Response(undefined, {
-						status: 401,
-						statusText: "Unauthorized",
-					});
-				}
-			}
-
-			return await file.default(req.clone(), matchedRoute, auth);
-		} else {
-			return new Response(undefined, {
-				status: 404,
-				statusText: "Route not found",
-			});
-		}
-	},
-});
-
-const logRequest = async (req: Request) => {
-	if (config.logging.log_requests_verbose) {
-		await appendFile(
-			`${process.cwd()}/logs/requests.log`,
-			`[${new Date().toISOString()}] ${req.method} ${
-				req.url
-			}\n\tHeaders:\n`
-		);
-
-		// Add headers
-
-		const headers = req.headers.entries();
-
-		for (const [key, value] of headers) {
-			await appendFile(
-				`${process.cwd()}/logs/requests.log`,
-				`\t\t${key}: ${value}\n`
-			);
-		}
-
-		const body = await req.clone().text();
-
-		await appendFile(
-			`${process.cwd()}/logs/requests.log`,
-			`\tBody:\n\t${body}\n`
-		);
-	} else if (config.logging.log_requests) {
-		await appendFile(
-			process.cwd() + "/logs/requests.log",
-			`[${new Date().toISOString()}] ${req.method} ${req.url}\n`
-		);
-	}
-};
-
-// Remove previous console.log
-// console.clear();
-
-console.log(
-	`${chalk.green(`✓`)} ${chalk.bold(
-		`Lysand started at ${chalk.blue(
-			`${config.http.bind}:${config.http.bind_port}`
-		)} in ${chalk.gray((performance.now() - timeAtStart).toFixed(0))}ms`
-	)}`
+await dualLogger.log(
+	LogLevel.INFO,
+	"Server",
+	`Lysand started at ${config.http.bind}:${config.http.bind_port} in ${(performance.now() - timeAtStart).toFixed(0)}ms`
 );
 
-console.log(
-	`${chalk.green(`✓`)} ${chalk.bold(`Database is ${chalk.blue("online")}`)}`
+await dualLogger.log(
+	LogLevel.INFO,
+	"Database",
+	`Database is online, now serving ${postCount} posts`
 );
 
-// Print "serving x posts"
-console.log(
-	`${chalk.green(`✓`)} ${chalk.bold(
-		`Serving ${chalk.blue(postCount)} posts`
-	)}`
-);
-
-server.emit(HookTypes.PostServe, {
-	postCount,
-});
+export { config, server };
diff --git a/package.json b/package.json
index 224545b0..83f8f88f 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
   "name": "lysand",
   "module": "index.ts",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "A project to build a federated social network",
   "author": {
     "email": "contact@cpluspatch.com",
@@ -32,14 +32,18 @@
   },
   "private": true,
   "scripts": {
-    "dev": "bun run index.ts",
-    "start": "bun run index.ts",
+    "dev": "bun run --watch index.ts",
+    "vite:dev": "bunx --bun vite pages",
+    "vite:build": "bunx --bun vite build pages",
+    "start": "NODE_ENV=production bun run dist/index.js --prod",
     "migrate-dev": "bun prisma migrate dev",
     "migrate": "bun prisma migrate deploy",
-    "lint": "eslint --config .eslintrc.cjs --ext .ts .",
-    "prisma": "bun run prisma.ts",
+    "lint": "bunx --bun eslint --config .eslintrc.cjs --ext .ts .",
+    "prod-build": "bunx --bun vite build pages && bun run build.ts",
+    "prisma": "DATABASE_URL=$(bun run prisma.ts) bunx prisma",
     "generate": "bun prisma generate",
     "benchmark:timeline": "bun run benchmarks/timelines.ts",
+    "cloc": "cloc . --exclude-dir node_modules,dist",
     "cli": "bun run cli.ts"
   },
   "trustedDependencies": [
@@ -53,9 +57,9 @@
     "@types/html-to-text": "^9.0.4",
     "@types/ioredis": "^5.0.0",
     "@types/jsonld": "^1.5.13",
-    "@typescript-eslint/eslint-plugin": "^6.13.1",
-    "@typescript-eslint/parser": "^6.13.1",
-    "@unocss/cli": "^0.57.7",
+    "@typescript-eslint/eslint-plugin": "latest",
+    "@typescript-eslint/parser": "latest",
+    "@unocss/cli": "latest",
     "activitypub-types": "^1.0.3",
     "bun-types": "latest",
     "eslint": "^8.54.0",
@@ -64,29 +68,52 @@
     "eslint-formatter-summary": "^1.1.0",
     "eslint-plugin-prettier": "^5.0.1",
     "prettier": "^3.1.0",
-    "typescript": "^5.3.2",
-    "unocss": "^0.57.7"
+    "typescript": "latest",
+    "unocss": "latest",
+    "@vitejs/plugin-vue": "latest",
+    "@vueuse/head": "^2.0.0",
+    "vite": "latest",
+    "vite-ssr": "^0.17.1",
+    "vue": "^3.3.9",
+    "vue-router": "^4.2.5",
+    "vue-tsc": "latest"
   },
   "peerDependencies": {
     "typescript": "^5.3.2"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.461.0",
+    "@iarna/toml": "^2.2.5",
+    "@json2csv/plainjs": "^7.0.6",
     "@prisma/client": "^5.6.0",
     "blurhash": "^2.0.5",
-    "bullmq": "^4.14.4",
+    "bullmq": "latest",
     "chalk": "^5.3.0",
+    "cli-parser": "file:packages/cli-parser",
     "cli-table": "^0.3.11",
+    "config-manager": "file:packages/config-manager",
     "eventemitter3": "^5.0.1",
+    "extract-zip": "^2.0.1",
     "html-to-text": "^9.0.5",
     "ioredis": "^5.3.2",
     "ip-matching": "^2.1.2",
     "iso-639-1": "^3.1.0",
-    "isomorphic-dompurify": "^1.10.0",
+    "isomorphic-dompurify": "latest",
     "jsonld": "^8.3.1",
-    "marked": "^9.1.2",
+    "linkify-html": "^4.1.3",
+    "linkify-string": "^4.1.3",
+    "linkifyjs": "^4.1.3",
+    "log-manager": "file:packages/log-manager",
+    "marked": "latest",
+    "media-manager": "file:packages/media-manager",
+    "megalodon": "^9.1.1",
+    "meilisearch": "latest",
+    "merge-deep-ts": "^1.2.6",
+    "next-route-matcher": "^1.0.1",
+    "oauth4webapi": "^2.4.0",
     "prisma": "^5.6.0",
     "prisma-redis-middleware": "^4.8.0",
+    "request-parser": "file:packages/request-parser",
     "semver": "^7.5.4",
     "sharp": "^0.33.0-rc.2"
   }
diff --git a/packages/cli-parser/bun.lockb b/packages/cli-parser/bun.lockb
new file mode 100755
index 00000000..249be439
Binary files /dev/null and b/packages/cli-parser/bun.lockb differ
diff --git a/packages/cli-parser/cli-builder.type.ts b/packages/cli-parser/cli-builder.type.ts
new file mode 100644
index 00000000..89c6dece
--- /dev/null
+++ b/packages/cli-parser/cli-builder.type.ts
@@ -0,0 +1,23 @@
+export interface CliParameter {
+	name: string;
+	/* Like -v for --version */
+	shortName?: string;
+	/**
+	 * If not positioned, the argument will need to be called with --name value instead of just value
+	 * @default true
+	 */
+	positioned?: boolean;
+	/* Whether the argument needs a value (requires positioned to be false) */
+	needsValue?: boolean;
+	optional?: true;
+	type: CliParameterType;
+	description?: string;
+}
+
+export enum CliParameterType {
+	STRING = "string",
+	NUMBER = "number",
+	BOOLEAN = "boolean",
+	ARRAY = "array",
+	EMPTY = "empty",
+}
diff --git a/packages/cli-parser/index.ts b/packages/cli-parser/index.ts
new file mode 100644
index 00000000..4554f096
--- /dev/null
+++ b/packages/cli-parser/index.ts
@@ -0,0 +1,420 @@
+import { CliParameterType, type CliParameter } from "./cli-builder.type";
+import chalk from "chalk";
+import strip from "strip-ansi";
+
+export function startsWithArray(fullArray: any[], startArray: any[]) {
+	if (startArray.length > fullArray.length) {
+		return false;
+	}
+	return fullArray
+		.slice(0, startArray.length)
+		.every((value, index) => value === startArray[index]);
+}
+
+interface TreeType {
+	[key: string]: CliCommand | TreeType;
+}
+
+/**
+ * Builder for a CLI
+ * @param commands Array of commands to register
+ */
+export class CliBuilder {
+	constructor(public commands: CliCommand[] = []) {}
+
+	/**
+	 * Add command to the CLI
+	 * @throws Error if command already exists
+	 * @param command Command to add
+	 */
+	registerCommand(command: CliCommand) {
+		if (this.checkIfCommandAlreadyExists(command)) {
+			throw new Error(
+				`Command category '${command.categories.join(" ")}' already exists`
+			);
+		}
+		this.commands.push(command);
+	}
+
+	/**
+	 * Add multiple commands to the CLI
+	 * @throws Error if command already exists
+	 * @param commands Commands to add
+	 */
+	registerCommands(commands: CliCommand[]) {
+		const existingCommand = commands.find(command =>
+			this.checkIfCommandAlreadyExists(command)
+		);
+		if (existingCommand) {
+			throw new Error(
+				`Command category '${existingCommand.categories.join(" ")}' already exists`
+			);
+		}
+		this.commands.push(...commands);
+	}
+
+	/**
+	 * Remove command from the CLI
+	 * @param command Command to remove
+	 */
+	deregisterCommand(command: CliCommand) {
+		this.commands = this.commands.filter(
+			registeredCommand => registeredCommand !== command
+		);
+	}
+
+	/**
+	 * Remove multiple commands from the CLI
+	 * @param commands Commands to remove
+	 */
+	deregisterCommands(commands: CliCommand[]) {
+		this.commands = this.commands.filter(
+			registeredCommand => !commands.includes(registeredCommand)
+		);
+	}
+
+	checkIfCommandAlreadyExists(command: CliCommand) {
+		return this.commands.some(
+			registeredCommand =>
+				registeredCommand.categories.length ==
+					command.categories.length &&
+				registeredCommand.categories.every(
+					(category, index) => category === command.categories[index]
+				)
+		);
+	}
+
+	/**
+	 * Get relevant args for the command (without executable or runtime)
+	 * @param args Arguments passed to the CLI
+	 */
+	private getRelevantArgs(args: string[]) {
+		if (args[0].startsWith("./")) {
+			// Formatted like ./cli.ts [command]
+			return args.slice(1);
+		} else if (args[0].includes("bun")) {
+			// Formatted like bun cli.ts [command]
+			return args.slice(2);
+		} else {
+			return args;
+		}
+	}
+
+	/**
+	 * Turn raw system args into a CLI command and run it
+	 * @param args Args directly from process.argv
+	 */
+	async processArgs(args: string[]) {
+		const revelantArgs = this.getRelevantArgs(args);
+
+		// Handle "-h", "--help" and "help" commands as special cases
+		if (revelantArgs.length === 1) {
+			if (["-h", "--help", "help"].includes(revelantArgs[0])) {
+				this.displayHelp();
+				return;
+			}
+		}
+
+		// Find revelant command
+		// Search for a command with as many categories matching args as possible
+		const matchingCommands = this.commands.filter(command =>
+			startsWithArray(revelantArgs, command.categories)
+		);
+
+		if (matchingCommands.length === 0) {
+			console.log(
+				`Invalid command "${revelantArgs.join(" ")}". Please use the ${chalk.bold("help")} command to see a list of commands`
+			);
+			return 0;
+		}
+
+		// Get command with largest category size
+		const command = matchingCommands.reduce((prev, current) =>
+			prev.categories.length > current.categories.length ? prev : current
+		);
+
+		const argsWithoutCategories = revelantArgs.slice(
+			command.categories.length
+		);
+
+		return await command.run(argsWithoutCategories);
+	}
+
+	/**
+	 * Recursively urns the commands into a tree where subcategories mark each sub-branch
+	 * @example
+	 * ```txt
+	 * user verify
+	 * user delete
+	 * user new admin
+	 * user new
+	 * ->
+	 * user
+	 *   verify
+	 *   delete
+	 *   new
+	 *     admin
+	 *     ""
+	 * ```
+	 */
+	getCommandTree(commands: CliCommand[]): TreeType {
+		const tree: TreeType = {};
+
+		for (const command of commands) {
+			let currentLevel = tree; // Start at the root
+
+			// Split the command into parts and iterate over them
+			for (const part of command.categories) {
+				// If this part doesn't exist in the current level of the tree, add it (__proto__ check to prevent prototype pollution)
+				// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+				if (!currentLevel[part] && part !== "__proto__") {
+					// If this is the last part of the command, add the command itself
+					if (
+						part ===
+						command.categories[command.categories.length - 1]
+					) {
+						currentLevel[part] = command;
+						break;
+					}
+					currentLevel[part] = {};
+				}
+
+				// Move down to the next level of the tree
+				currentLevel = currentLevel[part] as TreeType;
+			}
+		}
+
+		return tree;
+	}
+
+	/**
+	 * Display help for every command in a tree manner
+	 */
+	displayHelp() {
+		/*
+		user
+		  set
+		    admin: List of admin commands
+			  --prod: Whether to run in production
+			  --dev: Whether to run in development
+			  username: Username of the admin
+			  Example: user set admin --prod --dev --username John
+			delete
+			  ...
+		  verify
+		    ...
+		*/
+		const tree = this.getCommandTree(this.commands);
+		let writeBuffer = "";
+
+		const displayTree = (tree: TreeType, depth = 0) => {
+			for (const [key, value] of Object.entries(tree)) {
+				if (value instanceof CliCommand) {
+					writeBuffer += `${"    ".repeat(depth)}${chalk.blue(key)}|${chalk.underline(value.description)}\n`;
+					const positionedArgs = value.argTypes.filter(
+						arg => arg.positioned ?? true
+					);
+					const unpositionedArgs = value.argTypes.filter(
+						arg => !(arg.positioned ?? true)
+					);
+
+					for (const arg of positionedArgs) {
+						writeBuffer += `${"    ".repeat(depth + 1)}${chalk.green(
+							arg.name
+						)}|${
+							arg.description ?? "(no description)"
+						} ${arg.optional ? chalk.gray("(optional)") : ""}\n`;
+					}
+					for (const arg of unpositionedArgs) {
+						writeBuffer += `${"    ".repeat(depth + 1)}${chalk.yellow("--" + arg.name)}${arg.shortName ? ", " + chalk.yellow("-" + arg.shortName) : ""}|${
+							arg.description ?? "(no description)"
+						} ${arg.optional ? chalk.gray("(optional)") : ""}\n`;
+					}
+
+					if (value.example) {
+						writeBuffer += `${"    ".repeat(depth + 1)}${chalk.bold("Example:")} ${chalk.bgGray(
+							value.example
+						)}\n`;
+					}
+				} else {
+					writeBuffer += `${"    ".repeat(depth)}${chalk.blue(key)}\n`;
+					displayTree(value, depth + 1);
+				}
+			}
+		};
+
+		displayTree(tree);
+
+		// Replace all "|" with enough dots so that the text on the left + the dots = the same length
+		const optimal_length = Number(
+			// @ts-expect-error Slightly hacky but works
+			writeBuffer.split("\n").reduce((prev, current) => {
+				// If previousValue is empty
+				if (!prev)
+					return current.includes("|")
+						? current.split("|")[0].length
+						: 0;
+				if (!current.includes("|")) return prev;
+				const [left] = current.split("|");
+				// Strip ANSI color codes or they mess up the length
+				return Math.max(Number(prev), strip(left).length);
+			})
+		);
+
+		for (const line of writeBuffer.split("\n")) {
+			const [left, right] = line.split("|");
+			if (!right) {
+				console.log(left);
+				continue;
+			}
+			// Strip ANSI color codes or they mess up the length
+			const dots = ".".repeat(optimal_length + 5 - strip(left).length);
+			console.log(`${left}${dots}${right}`);
+		}
+	}
+}
+
+type ExecuteFunction<T> = (
+	instance: CliCommand,
+	args: Partial<T>
+	// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+) => Promise<number> | Promise<void> | number | void;
+
+/**
+ * A command that can be executed from the command line
+ * @param categories Example: `["user", "create"]` for the command `./cli user create --name John`
+ */
+export class CliCommand<T = any> {
+	constructor(
+		public categories: string[],
+		public argTypes: CliParameter[],
+		private execute: ExecuteFunction<T>,
+		public description?: string,
+		public example?: string
+	) {}
+
+	/**
+	 * Display help message for the command
+	 * formatted with Chalk and with emojis
+	 */
+	displayHelp() {
+		const positionedArgs = this.argTypes.filter(
+			arg => arg.positioned ?? true
+		);
+		const unpositionedArgs = this.argTypes.filter(
+			arg => !(arg.positioned ?? true)
+		);
+		const helpMessage = `
+${chalk.green("📚 Command:")} ${chalk.yellow(this.categories.join(" "))}
+${this.description ? `${chalk.cyan(this.description)}\n` : ""}
+${chalk.magenta("🔧 Arguments:")}
+${positionedArgs
+	.map(
+		arg =>
+			`${chalk.bold(arg.name)}: ${chalk.blue(arg.description ?? "(no description)")} ${
+				arg.optional ? chalk.gray("(optional)") : ""
+			}`
+	)
+	.join("\n")}
+${unpositionedArgs
+	.map(
+		arg =>
+			`--${chalk.bold(arg.name)}${arg.shortName ? `, -${arg.shortName}` : ""}: ${chalk.blue(arg.description ?? "(no description)")} ${
+				arg.optional ? chalk.gray("(optional)") : ""
+			}`
+	)
+	.join(
+		"\n"
+	)}${this.example ? `\n${chalk.magenta("🚀 Example:")}\n${chalk.bgGray(this.example)}` : ""}
+`;
+
+		console.log(helpMessage);
+	}
+
+	/**
+	 * Parses string array arguments into a full JavaScript object
+	 * @param argsWithoutCategories
+	 * @returns
+	 */
+	private parseArgs(argsWithoutCategories: string[]): Record<string, any> {
+		const parsedArgs: Record<string, any> = {};
+		let currentParameter: CliParameter | null = null;
+
+		for (let i = 0; i < argsWithoutCategories.length; i++) {
+			const arg = argsWithoutCategories[i];
+
+			if (arg.startsWith("--")) {
+				const argName = arg.substring(2);
+				currentParameter =
+					this.argTypes.find(argType => argType.name === argName) ||
+					null;
+				if (currentParameter && !currentParameter.needsValue) {
+					parsedArgs[argName] = true;
+					currentParameter = null;
+				} else if (currentParameter && currentParameter.needsValue) {
+					parsedArgs[argName] = this.castArgValue(
+						argsWithoutCategories[i + 1],
+						currentParameter.type
+					);
+					i++;
+					currentParameter = null;
+				}
+			} else if (arg.startsWith("-")) {
+				const shortName = arg.substring(1);
+				const argType = this.argTypes.find(
+					argType => argType.shortName === shortName
+				);
+				if (argType && !argType.needsValue) {
+					parsedArgs[argType.name] = true;
+				} else if (argType && argType.needsValue) {
+					parsedArgs[argType.name] = this.castArgValue(
+						argsWithoutCategories[i + 1],
+						argType.type
+					);
+					i++;
+				}
+			} else if (currentParameter) {
+				parsedArgs[currentParameter.name] = this.castArgValue(
+					arg,
+					currentParameter.type
+				);
+				currentParameter = null;
+			} else {
+				const positionedArgType = this.argTypes.find(
+					argType => argType.positioned && !parsedArgs[argType.name]
+				);
+				if (positionedArgType) {
+					parsedArgs[positionedArgType.name] = this.castArgValue(
+						arg,
+						positionedArgType.type
+					);
+				}
+			}
+		}
+
+		return parsedArgs;
+	}
+
+	private castArgValue(value: string, type: CliParameter["type"]): any {
+		switch (type) {
+			case CliParameterType.STRING:
+				return value;
+			case CliParameterType.NUMBER:
+				return Number(value);
+			case CliParameterType.BOOLEAN:
+				return value === "true";
+			case CliParameterType.ARRAY:
+				return value.split(",");
+			default:
+				return value;
+		}
+	}
+
+	/**
+	 * Runs the execute function with the parsed parameters as an argument
+	 */
+	async run(argsWithoutCategories: string[]) {
+		const args = this.parseArgs(argsWithoutCategories);
+		return await this.execute(this, args as any);
+	}
+}
diff --git a/packages/cli-parser/package.json b/packages/cli-parser/package.json
new file mode 100644
index 00000000..acc2e3ee
--- /dev/null
+++ b/packages/cli-parser/package.json
@@ -0,0 +1,6 @@
+{
+  "name": "arg-parser",
+  "version": "0.0.0",
+  "main": "index.ts",
+  "dependencies": { "strip-ansi": "^7.1.0" }
+}
\ No newline at end of file
diff --git a/packages/cli-parser/tests/cli-builder.test.ts b/packages/cli-parser/tests/cli-builder.test.ts
new file mode 100644
index 00000000..96ffdb08
--- /dev/null
+++ b/packages/cli-parser/tests/cli-builder.test.ts
@@ -0,0 +1,485 @@
+// FILEPATH: /home/jessew/Dev/lysand/packages/cli-parser/index.test.ts
+import { CliCommand, CliBuilder, startsWithArray } from "..";
+import { describe, beforeEach, it, expect, jest, spyOn } from "bun:test";
+import stripAnsi from "strip-ansi";
+import { CliParameterType } from "../cli-builder.type";
+
+describe("startsWithArray", () => {
+	it("should return true when fullArray starts with startArray", () => {
+		const fullArray = ["a", "b", "c", "d", "e"];
+		const startArray = ["a", "b", "c"];
+		expect(startsWithArray(fullArray, startArray)).toBe(true);
+	});
+
+	it("should return false when fullArray does not start with startArray", () => {
+		const fullArray = ["a", "b", "c", "d", "e"];
+		const startArray = ["b", "c", "d"];
+		expect(startsWithArray(fullArray, startArray)).toBe(false);
+	});
+
+	it("should return true when startArray is empty", () => {
+		const fullArray = ["a", "b", "c", "d", "e"];
+		const startArray: any[] = [];
+		expect(startsWithArray(fullArray, startArray)).toBe(true);
+	});
+
+	it("should return false when fullArray is shorter than startArray", () => {
+		const fullArray = ["a", "b", "c"];
+		const startArray = ["a", "b", "c", "d", "e"];
+		expect(startsWithArray(fullArray, startArray)).toBe(false);
+	});
+});
+
+describe("CliCommand", () => {
+	let cliCommand: CliCommand;
+
+	beforeEach(() => {
+		cliCommand = new CliCommand(
+			["category1", "category2"],
+			[
+				{
+					name: "arg1",
+					type: CliParameterType.STRING,
+					needsValue: true,
+				},
+				{
+					name: "arg2",
+					shortName: "a",
+					type: CliParameterType.NUMBER,
+					needsValue: true,
+				},
+				{
+					name: "arg3",
+					type: CliParameterType.BOOLEAN,
+					needsValue: false,
+				},
+				{
+					name: "arg4",
+					type: CliParameterType.ARRAY,
+					needsValue: true,
+				},
+			],
+			() => {
+				// Do nothing
+			}
+		);
+	});
+
+	it("should parse string arguments correctly", () => {
+		const args = cliCommand["parseArgs"]([
+			"--arg1",
+			"value1",
+			"--arg2",
+			"42",
+			"--arg3",
+			"--arg4",
+			"value1,value2",
+		]);
+		expect(args).toEqual({
+			arg1: "value1",
+			arg2: 42,
+			arg3: true,
+			arg4: ["value1", "value2"],
+		});
+	});
+
+	it("should parse short names for arguments too", () => {
+		const args = cliCommand["parseArgs"]([
+			"--arg1",
+			"value1",
+			"-a",
+			"42",
+			"--arg3",
+			"--arg4",
+			"value1,value2",
+		]);
+		expect(args).toEqual({
+			arg1: "value1",
+			arg2: 42,
+			arg3: true,
+			arg4: ["value1", "value2"],
+		});
+	});
+
+	it("should cast argument values correctly", () => {
+		expect(cliCommand["castArgValue"]("42", CliParameterType.NUMBER)).toBe(
+			42
+		);
+		expect(
+			cliCommand["castArgValue"]("true", CliParameterType.BOOLEAN)
+		).toBe(true);
+		expect(
+			cliCommand["castArgValue"]("value1,value2", CliParameterType.ARRAY)
+		).toEqual(["value1", "value2"]);
+	});
+
+	it("should run the execute function with the parsed parameters", async () => {
+		const mockExecute = jest.fn();
+		cliCommand = new CliCommand(
+			["category1", "category2"],
+			[
+				{
+					name: "arg1",
+					type: CliParameterType.STRING,
+					needsValue: true,
+				},
+				{
+					name: "arg2",
+					type: CliParameterType.NUMBER,
+					needsValue: true,
+				},
+				{
+					name: "arg3",
+					type: CliParameterType.BOOLEAN,
+					needsValue: false,
+				},
+				{
+					name: "arg4",
+					type: CliParameterType.ARRAY,
+					needsValue: true,
+				},
+			],
+			mockExecute
+		);
+
+		await cliCommand.run([
+			"--arg1",
+			"value1",
+			"--arg2",
+			"42",
+			"--arg3",
+			"--arg4",
+			"value1,value2",
+		]);
+		expect(mockExecute).toHaveBeenCalledWith(cliCommand, {
+			arg1: "value1",
+			arg2: 42,
+			arg3: true,
+			arg4: ["value1", "value2"],
+		});
+	});
+
+	it("should work with a mix of positioned and non-positioned arguments", async () => {
+		const mockExecute = jest.fn();
+		cliCommand = new CliCommand(
+			["category1", "category2"],
+			[
+				{
+					name: "arg1",
+					type: CliParameterType.STRING,
+					needsValue: true,
+				},
+				{
+					name: "arg2",
+					type: CliParameterType.NUMBER,
+					needsValue: true,
+				},
+				{
+					name: "arg3",
+					type: CliParameterType.BOOLEAN,
+					needsValue: false,
+				},
+				{
+					name: "arg4",
+					type: CliParameterType.ARRAY,
+					needsValue: true,
+				},
+				{
+					name: "arg5",
+					type: CliParameterType.STRING,
+					needsValue: true,
+					positioned: true,
+				},
+			],
+			mockExecute
+		);
+
+		await cliCommand.run([
+			"--arg1",
+			"value1",
+			"--arg2",
+			"42",
+			"--arg3",
+			"--arg4",
+			"value1,value2",
+			"value5",
+		]);
+
+		expect(mockExecute).toHaveBeenCalledWith(cliCommand, {
+			arg1: "value1",
+			arg2: 42,
+			arg3: true,
+			arg4: ["value1", "value2"],
+			arg5: "value5",
+		});
+	});
+
+	it("should display help message correctly", () => {
+		const consoleLogSpy = spyOn(console, "log").mockImplementation(() => {
+			// Do nothing
+		});
+
+		cliCommand = new CliCommand(
+			["category1", "category2"],
+			[
+				{
+					name: "arg1",
+					type: CliParameterType.STRING,
+					needsValue: true,
+					description: "Argument 1",
+					optional: true,
+				},
+				{
+					name: "arg2",
+					type: CliParameterType.NUMBER,
+					needsValue: true,
+					description: "Argument 2",
+				},
+				{
+					name: "arg3",
+					type: CliParameterType.BOOLEAN,
+					needsValue: false,
+					description: "Argument 3",
+					optional: true,
+					positioned: false,
+				},
+				{
+					name: "arg4",
+					type: CliParameterType.ARRAY,
+					needsValue: true,
+					description: "Argument 4",
+					positioned: false,
+				},
+			],
+			() => {
+				// Do nothing
+			},
+			"This is a test command",
+			"category1 category2 --arg1 value1 --arg2 42 arg3 --arg4 value1,value2"
+		);
+
+		cliCommand.displayHelp();
+
+		const loggedString = consoleLogSpy.mock.calls.map(call =>
+			stripAnsi(call[0])
+		)[0];
+
+		consoleLogSpy.mockRestore();
+
+		expect(loggedString).toContain("📚 Command: category1 category2");
+		expect(loggedString).toContain("🔧 Arguments:");
+		expect(loggedString).toContain("arg1: Argument 1 (optional)");
+		expect(loggedString).toContain("arg2: Argument 2");
+		expect(loggedString).toContain("--arg3: Argument 3 (optional)");
+		expect(loggedString).toContain("--arg4: Argument 4");
+		expect(loggedString).toContain("🚀 Example:");
+		expect(loggedString).toContain(
+			"category1 category2 --arg1 value1 --arg2 42 arg3 --arg4 value1,value2"
+		);
+	});
+});
+
+describe("CliBuilder", () => {
+	let cliBuilder: CliBuilder;
+	let mockCommand1: CliCommand;
+	let mockCommand2: CliCommand;
+
+	beforeEach(() => {
+		mockCommand1 = new CliCommand(["category1"], [], jest.fn());
+		mockCommand2 = new CliCommand(["category2"], [], jest.fn());
+		cliBuilder = new CliBuilder([mockCommand1]);
+	});
+
+	it("should register a command correctly", () => {
+		cliBuilder.registerCommand(mockCommand2);
+		expect(cliBuilder.commands).toContain(mockCommand2);
+	});
+
+	it("should register multiple commands correctly", () => {
+		const mockCommand3 = new CliCommand(["category3"], [], jest.fn());
+		cliBuilder.registerCommands([mockCommand2, mockCommand3]);
+		expect(cliBuilder.commands).toContain(mockCommand2);
+		expect(cliBuilder.commands).toContain(mockCommand3);
+	});
+
+	it("should error when adding duplicates", () => {
+		expect(() => {
+			cliBuilder.registerCommand(mockCommand1);
+		}).toThrow();
+
+		expect(() => {
+			cliBuilder.registerCommands([mockCommand1]);
+		}).toThrow();
+	});
+
+	it("should deregister a command correctly", () => {
+		cliBuilder.deregisterCommand(mockCommand1);
+		expect(cliBuilder.commands).not.toContain(mockCommand1);
+	});
+
+	it("should deregister multiple commands correctly", () => {
+		cliBuilder.registerCommand(mockCommand2);
+		cliBuilder.deregisterCommands([mockCommand1, mockCommand2]);
+		expect(cliBuilder.commands).not.toContain(mockCommand1);
+		expect(cliBuilder.commands).not.toContain(mockCommand2);
+	});
+
+	it("should process args correctly", async () => {
+		const mockExecute = jest.fn();
+		const mockCommand = new CliCommand(
+			["category1", "sub1"],
+			[
+				{
+					name: "arg1",
+					type: CliParameterType.STRING,
+					needsValue: true,
+					positioned: false,
+				},
+			],
+			mockExecute
+		);
+		cliBuilder.registerCommand(mockCommand);
+		await cliBuilder.processArgs([
+			"./cli.ts",
+			"category1",
+			"sub1",
+			"--arg1",
+			"value1",
+		]);
+		expect(mockExecute).toHaveBeenCalledWith(expect.anything(), {
+			arg1: "value1",
+		});
+	});
+
+	describe("should build command tree", () => {
+		let cliBuilder: CliBuilder;
+		let mockCommand1: CliCommand;
+		let mockCommand2: CliCommand;
+		let mockCommand3: CliCommand;
+		let mockCommand4: CliCommand;
+		let mockCommand5: CliCommand;
+
+		beforeEach(() => {
+			mockCommand1 = new CliCommand(["user", "verify"], [], jest.fn());
+			mockCommand2 = new CliCommand(["user", "delete"], [], jest.fn());
+			mockCommand3 = new CliCommand(
+				["user", "new", "admin"],
+				[],
+				jest.fn()
+			);
+			mockCommand4 = new CliCommand(["user", "new"], [], jest.fn());
+			mockCommand5 = new CliCommand(["admin", "delete"], [], jest.fn());
+			cliBuilder = new CliBuilder([
+				mockCommand1,
+				mockCommand2,
+				mockCommand3,
+				mockCommand4,
+				mockCommand5,
+			]);
+		});
+
+		it("should build the command tree correctly", () => {
+			const tree = cliBuilder.getCommandTree(cliBuilder.commands);
+			expect(tree).toEqual({
+				user: {
+					verify: mockCommand1,
+					delete: mockCommand2,
+					new: {
+						admin: mockCommand3,
+					},
+				},
+				admin: {
+					delete: mockCommand5,
+				},
+			});
+		});
+
+		it("should build the command tree correctly when there are no commands", () => {
+			cliBuilder = new CliBuilder([]);
+			const tree = cliBuilder.getCommandTree(cliBuilder.commands);
+			expect(tree).toEqual({});
+		});
+
+		it("should build the command tree correctly when there is only one command", () => {
+			cliBuilder = new CliBuilder([mockCommand1]);
+			const tree = cliBuilder.getCommandTree(cliBuilder.commands);
+			expect(tree).toEqual({
+				user: {
+					verify: mockCommand1,
+				},
+			});
+		});
+	});
+
+	it("should show help menu", () => {
+		const consoleLogSpy = spyOn(console, "log").mockImplementation(() => {
+			// Do nothing
+		});
+
+		const cliBuilder = new CliBuilder();
+
+		const cliCommand = new CliCommand(
+			["category1", "category2"],
+			[
+				{
+					name: "name",
+					type: CliParameterType.STRING,
+					needsValue: true,
+					description: "Name of new item",
+				},
+				{
+					name: "delete-previous",
+					type: CliParameterType.NUMBER,
+					needsValue: false,
+					positioned: false,
+					optional: true,
+					description: "Also delete the previous item",
+				},
+				{
+					name: "arg3",
+					type: CliParameterType.BOOLEAN,
+					needsValue: false,
+				},
+				{
+					name: "arg4",
+					type: CliParameterType.ARRAY,
+					needsValue: true,
+				},
+			],
+			() => {
+				// Do nothing
+			},
+			"I love sussy sauces",
+			"emoji add --url https://site.com/image.png"
+		);
+
+		cliBuilder.registerCommand(cliCommand);
+		cliBuilder.displayHelp();
+
+		const loggedString = consoleLogSpy.mock.calls
+			.map(call => stripAnsi(call[0]))
+			.join("\n");
+
+		consoleLogSpy.mockRestore();
+
+		expect(loggedString).toContain("category1");
+		expect(loggedString).toContain(
+			"    category2.................I love sussy sauces"
+		);
+		expect(loggedString).toContain(
+			"    name..................Name of new item"
+		);
+		expect(loggedString).toContain(
+			"    arg3..................(no description)"
+		);
+		expect(loggedString).toContain(
+			"    arg4..................(no description)"
+		);
+		expect(loggedString).toContain(
+			"    --delete-previous.....Also delete the previous item (optional)"
+		);
+		expect(loggedString).toContain(
+			"    Example: emoji add --url https://site.com/image.png"
+		);
+	});
+});
diff --git a/utils/config.ts b/packages/config-manager/config-type.type.ts
similarity index 87%
rename from utils/config.ts
rename to packages/config-manager/config-type.type.ts
index 92553c16..4d4b9570 100644
--- a/utils/config.ts
+++ b/packages/config-manager/config-type.type.ts
@@ -1,4 +1,4 @@
-import data from "../config/config.toml";
+import { MediaBackendType } from "media-manager";
 
 export interface ConfigType {
 	database: {
@@ -25,11 +25,36 @@ export interface ConfigType {
 		};
 	};
 
+	meilisearch: {
+		host: string;
+		port: number;
+		api_key: string;
+		enabled: boolean;
+	};
+
+	signups: {
+		tos_url: string;
+		rules: string[];
+		registration: boolean;
+	};
+
+	oidc: {
+		providers: {
+			name: string;
+			id: string;
+			url: string;
+			client_id: string;
+			client_secret: string;
+			icon: string;
+		}[];
+	};
+
 	http: {
 		base_url: string;
 		bind: string;
 		bind_port: string;
 		banned_ips: string[];
+		banned_user_agents: string[];
 	};
 
 	instance: {
@@ -72,12 +97,13 @@ export interface ConfigType {
 	};
 
 	media: {
-		backend: string;
+		backend: MediaBackendType;
 		deduplicate_media: boolean;
 		conversion: {
 			convert_images: boolean;
 			convert_to: string;
 		};
+		local_uploads_folder: string;
 	};
 
 	s3: {
@@ -129,6 +155,7 @@ export interface ConfigType {
 	logging: {
 		log_requests: boolean;
 		log_requests_verbose: boolean;
+		log_ip: boolean;
 		log_filters: boolean;
 	};
 
@@ -153,6 +180,7 @@ export const configDefaults: ConfigType = {
 		bind_port: "8000",
 		base_url: "http://lysand.localhost:8000",
 		banned_ips: [],
+		banned_user_agents: [],
 	},
 	database: {
 		host: "localhost",
@@ -176,6 +204,20 @@ export const configDefaults: ConfigType = {
 			enabled: false,
 		},
 	},
+	meilisearch: {
+		host: "localhost",
+		port: 1491,
+		api_key: "",
+		enabled: false,
+	},
+	signups: {
+		tos_url: "",
+		rules: [],
+		registration: false,
+	},
+	oidc: {
+		providers: [],
+	},
 	instance: {
 		banner: "",
 		description: "",
@@ -190,12 +232,13 @@ export const configDefaults: ConfigType = {
 		username: "",
 	},
 	media: {
-		backend: "local",
+		backend: MediaBackendType.LOCAL,
 		deduplicate_media: true,
 		conversion: {
 			convert_images: false,
 			convert_to: "webp",
 		},
+		local_uploads_folder: "uploads",
 	},
 	email: {
 		send_on_report: false,
@@ -311,6 +354,7 @@ export const configDefaults: ConfigType = {
 	logging: {
 		log_requests: false,
 		log_requests_verbose: false,
+		log_ip: false,
 		log_filters: true,
 	},
 	ratelimits: {
@@ -319,16 +363,3 @@ export const configDefaults: ConfigType = {
 	},
 	custom_ratelimits: {},
 };
-
-export const getConfig = () => {
-	return {
-		...configDefaults,
-		...(data as ConfigType),
-	};
-};
-
-export const getHost = () => {
-	const url = new URL(getConfig().http.base_url);
-
-	return url.host;
-};
diff --git a/packages/config-manager/index.ts b/packages/config-manager/index.ts
new file mode 100644
index 00000000..d9cbb52f
--- /dev/null
+++ b/packages/config-manager/index.ts
@@ -0,0 +1,122 @@
+/**
+ * @file index.ts
+ * @summary ConfigManager system to retrieve and modify system configuration
+ * @description Can read from a hand-written file, config.toml, or from a machine-saved file, config.internal.toml
+ * Fuses both and provides a way to retrieve individual values
+ */
+
+import { parse, stringify, type JsonMap } from "@iarna/toml";
+import type { ConfigType } from "./config-type.type";
+import { configDefaults } from "./config-type.type";
+import merge from "merge-deep-ts";
+
+export class ConfigManager {
+	constructor(
+		public config: {
+			configPathOverride?: string;
+			internalConfigPathOverride?: string;
+		}
+	) {}
+
+	/**
+	 * @summary Reads the config files and returns the merge as a JSON object
+	 * @returns {Promise<T = ConfigType>} The merged config file as a JSON object
+	 */
+	async getConfig<T = ConfigType>() {
+		const config = await this.readConfig<T>();
+		const internalConfig = await this.readInternalConfig<T>();
+
+		return this.mergeConfigs<T>(config, internalConfig);
+	}
+
+	getConfigPath() {
+		return (
+			this.config.configPathOverride ||
+			process.cwd() + "/config/config.toml"
+		);
+	}
+
+	getInternalConfigPath() {
+		return (
+			this.config.internalConfigPathOverride ||
+			process.cwd() + "/config/config.internal.toml"
+		);
+	}
+
+	/**
+	 * @summary Reads the internal config file and returns it as a JSON object
+	 * @returns {Promise<T = ConfigType>} The internal config file as a JSON object
+	 */
+	private async readInternalConfig<T = ConfigType>() {
+		const config = Bun.file(this.getInternalConfigPath());
+
+		if (!(await config.exists())) {
+			await Bun.write(config, "");
+		}
+
+		return this.parseConfig<T>(await config.text());
+	}
+
+	/**
+	 * @summary Reads the config file and returns it as a JSON object
+	 * @returns {Promise<T = ConfigType>} The config file as a JSON object
+	 */
+	private async readConfig<T = ConfigType>() {
+		const config = Bun.file(this.getConfigPath());
+
+		if (!(await config.exists())) {
+			throw new Error(
+				`Error while reading config at path ${this.getConfigPath()}: Config file not found`
+			);
+		}
+
+		return this.parseConfig<T>(await config.text());
+	}
+
+	/**
+	 * @summary Parses a TOML string and returns it as a JSON object
+	 * @param text The TOML string to parse
+	 * @returns {T = ConfigType} The parsed TOML string as a JSON object
+	 * @throws {Error} If the TOML string is invalid
+	 * @private
+	 */
+	private parseConfig<T = ConfigType>(text: string) {
+		try {
+			// To all [Symbol] keys from the object
+			return JSON.parse(JSON.stringify(parse(text))) as T;
+		} catch (e: any) {
+			throw new Error(
+				`Error while parsing config at path ${this.getConfigPath()}: ${e}`
+			);
+		}
+	}
+
+	/**
+	 * Writes changed values to the internal config
+	 * @param config The new config object
+	 */
+	async writeConfig<T = ConfigType>(config: T) {
+		const path = this.getInternalConfigPath();
+		const file = Bun.file(path);
+
+		await Bun.write(
+			file,
+			`# THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT IT MANUALLY, EDIT THE STANDARD CONFIG.TOML INSTEAD.\n${stringify(
+				config as JsonMap
+			)}`
+		);
+	}
+
+	/**
+	 * @summary Merges two config objects together, with
+	 * the latter configs' values taking precedence
+	 * @param configs
+	 * @returns
+	 */
+	private mergeConfigs<T = ConfigType>(...configs: T[]) {
+		return merge(configs) as T;
+	}
+}
+
+export type { ConfigType };
+export const defaultConfig = configDefaults;
diff --git a/packages/config-manager/package.json b/packages/config-manager/package.json
new file mode 100644
index 00000000..e3c7ad60
--- /dev/null
+++ b/packages/config-manager/package.json
@@ -0,0 +1,6 @@
+{
+    "name": "config-manager",
+    "version": "0.0.0",
+    "main": "index.ts",
+    "dependencies": {}
+}
\ No newline at end of file
diff --git a/packages/config-manager/tests/config-manager.test.ts b/packages/config-manager/tests/config-manager.test.ts
new file mode 100644
index 00000000..2635aba2
--- /dev/null
+++ b/packages/config-manager/tests/config-manager.test.ts
@@ -0,0 +1,96 @@
+// FILEPATH: /home/jessew/Dev/lysand/packages/config-manager/config-manager.test.ts
+import { stringify } from "@iarna/toml";
+import { ConfigManager } from "..";
+import { describe, beforeEach, spyOn, it, expect } from "bun:test";
+
+describe("ConfigManager", () => {
+	let configManager: ConfigManager;
+
+	beforeEach(() => {
+		configManager = new ConfigManager({
+			configPathOverride: "./config/config.toml",
+			internalConfigPathOverride: "./config/config.internal.toml",
+		});
+	});
+
+	it("should get the correct config path", () => {
+		expect(configManager.getConfigPath()).toEqual("./config/config.toml");
+	});
+
+	it("should get the correct internal config path", () => {
+		expect(configManager.getInternalConfigPath()).toEqual(
+			"./config/config.internal.toml"
+		);
+	});
+
+	it("should read the config file correctly", async () => {
+		const mockConfig = { key: "value" };
+
+		// @ts-expect-error This is a mock
+		spyOn(Bun, "file").mockImplementationOnce(() => ({
+			exists: () =>
+				new Promise(resolve => {
+					resolve(true);
+				}),
+			text: () =>
+				new Promise(resolve => {
+					resolve(stringify(mockConfig));
+				}),
+		}));
+
+		const config = await configManager.getConfig<typeof mockConfig>();
+
+		expect(config).toEqual(mockConfig);
+	});
+
+	it("should read the internal config file correctly", async () => {
+		const mockConfig = { key: "value" };
+
+		// @ts-expect-error This is a mock
+		spyOn(Bun, "file").mockImplementationOnce(() => ({
+			exists: () =>
+				new Promise(resolve => {
+					resolve(true);
+				}),
+			text: () =>
+				new Promise(resolve => {
+					resolve(stringify(mockConfig));
+				}),
+		}));
+
+		const config =
+			// @ts-expect-error Force call private function for testing
+			await configManager.readInternalConfig<typeof mockConfig>();
+
+		expect(config).toEqual(mockConfig);
+	});
+
+	it("should write to the internal config file correctly", async () => {
+		const mockConfig = { key: "value" };
+
+		spyOn(Bun, "write").mockImplementationOnce(
+			() =>
+				new Promise(resolve => {
+					resolve(10);
+				})
+		);
+
+		await configManager.writeConfig(mockConfig);
+	});
+
+	it("should merge configs correctly", () => {
+		const config1 = { key1: "value1", key2: "value2" };
+		const config2 = { key2: "newValue2", key3: "value3" };
+		// @ts-expect-error Force call private function for testing
+		const mergedConfig = configManager.mergeConfigs<Record<string, string>>(
+			config1,
+			config2
+		);
+
+		expect(mergedConfig).toEqual({
+			key1: "value1",
+			key2: "newValue2",
+			key3: "value3",
+		});
+	});
+});
diff --git a/packages/log-manager/index.ts b/packages/log-manager/index.ts
new file mode 100644
index 00000000..37d03e1d
--- /dev/null
+++ b/packages/log-manager/index.ts
@@ -0,0 +1,171 @@
+import type { BunFile } from "bun";
+import { appendFile } from "fs/promises";
+
+export enum LogLevel {
+	DEBUG = "debug",
+	INFO = "info",
+	WARNING = "warning",
+	ERROR = "error",
+	CRITICAL = "critical",
+}
+
+/**
+ * Class for handling logging to disk or to stdout
+ * @param output BunFile of output (can be a normal file or something like Bun.stdout)
+ */
+export class LogManager {
+	constructor(private output: BunFile) {
+		void this.write(
+			`--- INIT LogManager at ${new Date().toISOString()} ---`
+		);
+	}
+
+	/**
+	 * Logs a message to the output
+	 * @param level Importance of the log
+	 * @param entity Emitter of the log
+	 * @param message Message to log
+	 * @param showTimestamp Whether to show the timestamp in the log
+	 */
+	async log(
+		level: LogLevel,
+		entity: string,
+		message: string,
+		showTimestamp = true
+	) {
+		await this.write(
+			`${showTimestamp ? new Date().toISOString() + " " : ""}[${level.toUpperCase()}] ${entity}: ${message}`
+		);
+	}
+
+	private async write(text: string) {
+		if (this.output == Bun.stdout) {
+			await Bun.write(Bun.stdout, text + "\n");
+		} else {
+			if (!this.output.name) {
+				throw new Error(`Output file doesnt exist (and isnt stdout)`);
+			}
+			await appendFile(this.output.name, text + "\n");
+		}
+	}
+
+	/**
+	 * Logs an error to the output, wrapper for log
+	 * @param level Importance of the log
+	 * @param entity Emitter of the log
+	 * @param error Error to log
+	 */
+	async logError(level: LogLevel, entity: string, error: Error) {
+		await this.log(level, entity, error.message);
+	}
+
+	/**
+	 * Logs a request to the output
+	 * @param req Request to log
+	 * @param ip IP of the request
+	 * @param logAllDetails Whether to log all details of the request
+	 */
+	async logRequest(req: Request, ip?: string, logAllDetails = false) {
+		let string = ip ? `${ip}: ` : "";
+
+		string += `${req.method} ${req.url}`;
+
+		if (logAllDetails) {
+			string += `\n`;
+			string += `  [Headers]\n`;
+			// Pretty print headers
+			for (const [key, value] of req.headers.entries()) {
+				string += `    ${key}: ${value}\n`;
+			}
+
+			// Pretty print body
+			string += `  [Body]\n`;
+			const content_type = req.headers.get("Content-Type");
+
+			if (content_type && content_type.includes("application/json")) {
+				const json = await req.json();
+				const stringified = JSON.stringify(json, null, 4)
+					.split("\n")
+					.map(line => `    ${line}`)
+					.join("\n");
+
+				string += `${stringified}\n`;
+			} else if (
+				content_type &&
+				(content_type.includes("application/x-www-form-urlencoded") ||
+					content_type.includes("multipart/form-data"))
+			) {
+				const formData = await req.formData();
+				for (const [key, value] of formData.entries()) {
+					if (value.toString().length < 300) {
+						string += `    ${key}: ${value.toString()}\n`;
+					} else {
+						string += `    ${key}: <${value.toString().length} bytes>\n`;
+					}
+				}
+			} else {
+				const text = await req.text();
+				string += `    ${text}\n`;
+			}
+		}
+		await this.log(LogLevel.INFO, "Request", string);
+	}
+}
+
+/**
+ * Outputs to multiple LogManager instances at once
+ */
+export class MultiLogManager {
+	constructor(private logManagers: LogManager[]) {}
+
+	/**
+	 * Logs a message to all logManagers
+	 * @param level Importance of the log
+	 * @param entity Emitter of the log
+	 * @param message Message to log
+	 * @param showTimestamp Whether to show the timestamp in the log
+	 */
+	async log(
+		level: LogLevel,
+		entity: string,
+		message: string,
+		showTimestamp = true
+	) {
+		for (const logManager of this.logManagers) {
+			await logManager.log(level, entity, message, showTimestamp);
+		}
+	}
+
+	/**
+	 * Logs an error to all logManagers
+	 * @param level Importance of the log
+	 * @param entity Emitter of the log
+	 * @param error Error to log
+	 */
+	async logError(level: LogLevel, entity: string, error: Error) {
+		for (const logManager of this.logManagers) {
+			await logManager.logError(level, entity, error);
+		}
+	}
+
+	/**
+	 * Logs a request to all logManagers
+	 * @param req Request to log
+	 * @param ip IP of the request
+	 * @param logAllDetails Whether to log all details of the request
+	 */
+	async logRequest(req: Request, ip?: string, logAllDetails = false) {
+		for (const logManager of this.logManagers) {
+			await logManager.logRequest(req, ip, logAllDetails);
+		}
+	}
+
+	/**
+	 * Create a MultiLogManager from multiple LogManager instances
+	 * @param logManagers LogManager instances to use
+	 * @returns
+	 */
+	static fromLogManagers(...logManagers: LogManager[]) {
+		return new MultiLogManager(logManagers);
+	}
+}
diff --git a/packages/log-manager/package.json b/packages/log-manager/package.json
new file mode 100644
index 00000000..679a8262
--- /dev/null
+++ b/packages/log-manager/package.json
@@ -0,0 +1,6 @@
+{
+    "name": "log-manager",
+    "version": "0.0.0",
+    "main": "index.ts",
+    "dependencies": {  }
+  }
\ No newline at end of file
diff --git a/packages/log-manager/tests/log-manager.test.ts b/packages/log-manager/tests/log-manager.test.ts
new file mode 100644
index 00000000..6b8b7bf5
--- /dev/null
+++ b/packages/log-manager/tests/log-manager.test.ts
@@ -0,0 +1,231 @@
+// FILEPATH: /home/jessew/Dev/lysand/packages/log-manager/log-manager.test.ts
+import { LogManager, LogLevel, MultiLogManager } from "../index";
+import type fs from "fs/promises";
+import {
+	describe,
+	it,
+	beforeEach,
+	expect,
+	jest,
+	mock,
+	type Mock,
+	test,
+} from "bun:test";
+import type { BunFile } from "bun";
+
+describe("LogManager", () => {
+	let logManager: LogManager;
+	let mockOutput: BunFile;
+	let mockAppend: Mock<typeof fs.appendFile>;
+
+	beforeEach(async () => {
+		mockOutput = Bun.file("test.log");
+		mockAppend = jest.fn();
+		await mock.module("fs/promises", () => ({
+			appendFile: mockAppend,
+		}));
+		logManager = new LogManager(mockOutput);
+	});
+
+	it("should initialize and write init log", () => {
+		expect(mockAppend).toHaveBeenCalledWith(
+			mockOutput.name,
+			expect.stringContaining("--- INIT LogManager at")
+		);
+	});
+
+	it("should log message with timestamp", async () => {
+		await logManager.log(LogLevel.INFO, "TestEntity", "Test message");
+		expect(mockAppend).toHaveBeenCalledWith(
+			mockOutput.name,
+			expect.stringContaining("[INFO] TestEntity: Test message")
+		);
+	});
+
+	it("should log message without timestamp", async () => {
+		await logManager.log(
+			LogLevel.INFO,
+			"TestEntity",
+			"Test message",
+			false
+		);
+		expect(mockAppend).toHaveBeenCalledWith(
+			mockOutput.name,
+			"[INFO] TestEntity: Test message\n"
+		);
+	});
+
+	test.skip("should write to stdout", async () => {
+		logManager = new LogManager(Bun.stdout);
+		await logManager.log(LogLevel.INFO, "TestEntity", "Test message");
+
+		const writeMock = jest.fn();
+
+		await mock.module("Bun", () => ({
+			stdout: Bun.stdout,
+			write: writeMock,
+		}));
+
+		expect(writeMock).toHaveBeenCalledWith(
+			Bun.stdout,
+			expect.stringContaining("[INFO] TestEntity: Test message")
+		);
+	});
+
+	it("should throw error if output file does not exist", () => {
+		mockAppend.mockImplementationOnce(() => {
+			return Promise.reject(
+				new Error("Output file doesnt exist (and isnt stdout)")
+			);
+		});
+		expect(
+			logManager.log(LogLevel.INFO, "TestEntity", "Test message")
+		).rejects.toThrow(Error);
+	});
+
+	it("should log error message", async () => {
+		const error = new Error("Test error");
+		await logManager.logError(LogLevel.ERROR, "TestEntity", error);
+		expect(mockAppend).toHaveBeenCalledWith(
+			mockOutput.name,
+			expect.stringContaining("[ERROR] TestEntity: Test error")
+		);
+	});
+
+	it("should log basic request details", async () => {
+		const req = new Request("http://localhost/test", { method: "GET" });
+		await logManager.logRequest(req, "127.0.0.1");
+
+		expect(mockAppend).toHaveBeenCalledWith(
+			mockOutput.name,
+			expect.stringContaining("127.0.0.1: GET http://localhost/test")
+		);
+	});
+
+	describe("Request logger", () => {
+		it("should log all request details for JSON content type", async () => {
+			const req = new Request("http://localhost/test", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ test: "value" }),
+			});
+			await logManager.logRequest(req, "127.0.0.1", true);
+
+			const expectedLog = `127.0.0.1: POST http://localhost/test
+  [Headers]
+    content-type: application/json
+  [Body]
+    {
+        "test": "value"
+    }
+`;
+
+			expect(mockAppend).toHaveBeenCalledWith(
+				mockOutput.name,
+				expect.stringContaining(expectedLog)
+			);
+		});
+
+		it("should log all request details for text content type", async () => {
+			const req = new Request("http://localhost/test", {
+				method: "POST",
+				headers: { "Content-Type": "text/plain" },
+				body: "Test body",
+			});
+			await logManager.logRequest(req, "127.0.0.1", true);
+
+			const expectedLog = `127.0.0.1: POST http://localhost/test
+  [Headers]
+    content-type: text/plain
+  [Body]
+    Test body
+`;
+			expect(mockAppend).toHaveBeenCalledWith(
+				mockOutput.name,
+				expect.stringContaining(expectedLog)
+			);
+		});
+
+		it("should log all request details for FormData content-type", async () => {
+			const formData = new FormData();
+			formData.append("test", "value");
+			const req = new Request("http://localhost/test", {
+				method: "POST",
+				body: formData,
+			});
+			await logManager.logRequest(req, "127.0.0.1", true);
+
+			const expectedLog = `127.0.0.1: POST http://localhost/test
+  [Headers]
+    content-type: multipart/form-data; boundary=${
+		req.headers.get("Content-Type")?.split("boundary=")[1] ?? ""
+	}
+  [Body]
+    test: value
+`;
+
+			expect(mockAppend).toHaveBeenCalledWith(
+				mockOutput.name,
+				expect.stringContaining(
+					expectedLog.replace("----", expect.any(String))
+				)
+			);
+		});
+	});
+});
+
+describe("MultiLogManager", () => {
+	let multiLogManager: MultiLogManager;
+	let mockLogManagers: LogManager[];
+	let mockLog: jest.Mock;
+	let mockLogError: jest.Mock;
+	let mockLogRequest: jest.Mock;
+
+	beforeEach(() => {
+		mockLog = jest.fn();
+		mockLogError = jest.fn();
+		mockLogRequest = jest.fn();
+		mockLogManagers = [
+			{
+				log: mockLog,
+				logError: mockLogError,
+				logRequest: mockLogRequest,
+			},
+			{
+				log: mockLog,
+				logError: mockLogError,
+				logRequest: mockLogRequest,
+			},
+		] as unknown as LogManager[];
+		multiLogManager = MultiLogManager.fromLogManagers(...mockLogManagers);
+	});
+
+	it("should log message to all logManagers", async () => {
+		await multiLogManager.log(LogLevel.INFO, "TestEntity", "Test message");
+		expect(mockLog).toHaveBeenCalledTimes(2);
+		expect(mockLog).toHaveBeenCalledWith(
+			LogLevel.INFO,
+			"TestEntity",
+			"Test message",
+			true
+		);
+	});
+
+	it("should log error to all logManagers", async () => {
+		const error = new Error("Test error");
+		await multiLogManager.logError(LogLevel.ERROR, "TestEntity", error);
+		expect(mockLogError).toHaveBeenCalledTimes(2);
+		expect(mockLogError).toHaveBeenCalledWith(
+			LogLevel.ERROR,
+			"TestEntity",
+			error
+		);
+	});
+
+	it("should log request to all logManagers", async () => {
+		const req = new Request("http://localhost/test", { method: "GET" });
+		await multiLogManager.logRequest(req, "127.0.0.1", true);
+		expect(mockLogRequest).toHaveBeenCalledTimes(2);
+		expect(mockLogRequest).toHaveBeenCalledWith(req, "127.0.0.1", true);
+	});
+});
diff --git a/packages/media-manager/backends/local.ts b/packages/media-manager/backends/local.ts
new file mode 100644
index 00000000..d5a8fb99
--- /dev/null
+++ b/packages/media-manager/backends/local.ts
@@ -0,0 +1,64 @@
+import type { ConvertableMediaFormats } from "../media-converter";
+import { MediaConverter } from "../media-converter";
+import { MediaBackend, MediaBackendType, MediaHasher } from "..";
+import type { ConfigType } from "config-manager";
+
+export class LocalMediaBackend extends MediaBackend {
+	constructor(config: ConfigType) {
+		super(config, MediaBackendType.LOCAL);
+	}
+
+	public async addFile(file: File) {
+		if (this.shouldConvertImages(this.config)) {
+			const fileExtension = file.name.split(".").pop();
+			const mediaConverter = new MediaConverter(
+				fileExtension as ConvertableMediaFormats,
+				this.config.media.conversion
+					.convert_to as ConvertableMediaFormats
+			);
+			file = await mediaConverter.convert(file);
+		}
+
+		const hash = await new MediaHasher().getMediaHash(file);
+
+		const newFile = Bun.file(
+			`${this.config.media.local_uploads_folder}/${hash}`
+		);
+
+		if (await newFile.exists()) {
+			throw new Error("File already exists");
+		}
+
+		await Bun.write(newFile, file);
+
+		return {
+			uploadedFile: file,
+			path: `./uploads/${file.name}`,
+			hash: hash,
+		};
+	}
+
+	public async getFileByHash(
+		hash: string,
+		databaseHashFetcher: (sha256: string) => Promise<string | null>
+	): Promise<File | null> {
+		const filename = await databaseHashFetcher(hash);
+
+		if (!filename) return null;
+
+		return this.getFile(filename);
+	}
+
+	public async getFile(filename: string): Promise<File | null> {
+		const file = Bun.file(
+			`${this.config.media.local_uploads_folder}/${filename}`
+		);
+
+		if (!(await file.exists())) return null;
+
+		return new File([await file.arrayBuffer()], filename, {
+			type: file.type,
+			lastModified: file.lastModified,
+		});
+	}
+}
diff --git a/packages/media-manager/backends/s3.ts b/packages/media-manager/backends/s3.ts
new file mode 100644
index 00000000..46c2cb41
--- /dev/null
+++ b/packages/media-manager/backends/s3.ts
@@ -0,0 +1,69 @@
+import { S3Client } from "@bradenmacdonald/s3-lite-client";
+import type { ConvertableMediaFormats } from "../media-converter";
+import { MediaConverter } from "../media-converter";
+import { MediaBackend, MediaBackendType, MediaHasher } from "..";
+import type { ConfigType } from "config-manager";
+
+export class S3MediaBackend extends MediaBackend {
+	constructor(
+		config: ConfigType,
+		private s3Client = new S3Client({
+			endPoint: config.s3.endpoint,
+			useSSL: true,
+			region: config.s3.region || "auto",
+			bucket: config.s3.bucket_name,
+			accessKey: config.s3.access_key,
+			secretKey: config.s3.secret_access_key,
+		})
+	) {
+		super(config, MediaBackendType.S3);
+	}
+
+	public async addFile(file: File) {
+		if (this.shouldConvertImages(this.config)) {
+			const fileExtension = file.name.split(".").pop();
+			const mediaConverter = new MediaConverter(
+				fileExtension as ConvertableMediaFormats,
+				this.config.media.conversion
+					.convert_to as ConvertableMediaFormats
+			);
+			file = await mediaConverter.convert(file);
+		}
+
+		const hash = await new MediaHasher().getMediaHash(file);
+
+		await this.s3Client.putObject(file.name, file.stream(), {
+			size: file.size,
+		});
+
+		return {
+			uploadedFile: file,
+			hash: hash,
+		};
+	}
+
+	public async getFileByHash(
+		hash: string,
+		databaseHashFetcher: (sha256: string) => Promise<string | null>
+	): Promise<File | null> {
+		const filename = await databaseHashFetcher(hash);
+
+		if (!filename) return null;
+
+		return this.getFile(filename);
+	}
+
+	public async getFile(filename: string): Promise<File | null> {
+		try {
+			await this.s3Client.statObject(filename);
+		} catch {
+			return null;
+		}
+
+		const file = await this.s3Client.getObject(filename);
+
+		return new File([await file.arrayBuffer()], filename, {
+			type: file.headers.get("Content-Type") || "undefined",
+		});
+	}
+}
diff --git a/packages/media-manager/bun.lockb b/packages/media-manager/bun.lockb
new file mode 100755
index 00000000..202c862d
Binary files /dev/null and b/packages/media-manager/bun.lockb differ
diff --git a/packages/media-manager/bunfig.toml b/packages/media-manager/bunfig.toml
new file mode 100644
index 00000000..bea1efe1
--- /dev/null
+++ b/packages/media-manager/bunfig.toml
@@ -0,0 +1,2 @@
+[install.scopes]
+"@jsr" = "https://npm.jsr.io"
diff --git a/packages/media-manager/index.ts b/packages/media-manager/index.ts
new file mode 100644
index 00000000..1dc24dba
--- /dev/null
+++ b/packages/media-manager/index.ts
@@ -0,0 +1,101 @@
+import type { ConfigType } from "config-manager";
+
+export enum MediaBackendType {
+	LOCAL = "local",
+	S3 = "s3",
+}
+
+interface UploadedFileMetadata {
+	uploadedFile: File;
+	path?: string;
+	hash: string;
+}
+
+export class MediaHasher {
+	/**
+	 * Returns the SHA-256 hash of a file in hex format
+	 * @param media The file to hash
+	 * @returns The SHA-256 hash of the file in hex format
+	 */
+	public async getMediaHash(media: File) {
+		const hash = new Bun.SHA256()
+			.update(await media.arrayBuffer())
+			.digest("hex");
+
+		return hash;
+	}
+}
+
+export class MediaBackend {
+	constructor(
+		public config: ConfigType,
+		public backend: MediaBackendType
+	) {}
+
+	static async fromBackendType(
+		backend: MediaBackendType,
+		config: ConfigType
+	): Promise<MediaBackend> {
+		switch (backend) {
+			case MediaBackendType.LOCAL:
+				return new (await import("./backends/local")).LocalMediaBackend(
+					config
+				);
+			case MediaBackendType.S3:
+				return new (await import("./backends/s3")).S3MediaBackend(
+					config
+				);
+			default:
+				throw new Error(`Unknown backend type: ${backend as any}`);
+		}
+	}
+
+	public getBackendType() {
+		return this.backend;
+	}
+
+	public shouldConvertImages(config: ConfigType) {
+		return config.media.conversion.convert_images;
+	}
+
+	/**
+	 * Fetches file from backend from SHA-256 hash
+	 * @param file SHA-256 hash of wanted file
+	 * @param databaseHashFetcher Function that takes in a sha256 hash as input and outputs the filename of that file in the database
+	 * @returns The file as a File object
+	 */
+	public getFileByHash(
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		file: string,
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		databaseHashFetcher: (sha256: string) => Promise<string>
+	): Promise<File | null> {
+		return Promise.reject(
+			new Error("Do not call MediaBackend directly: use a subclass")
+		);
+	}
+
+	/**
+	 * Fetches file from backend from filename
+	 * @param filename File name
+	 * @returns The file as a File object
+	 */
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	public getFile(filename: string): Promise<File | null> {
+		return Promise.reject(
+			new Error("Do not call MediaBackend directly: use a subclass")
+		);
+	}
+
+	/**
+	 * Adds file to backend
+	 * @param file File to add
+	 * @returns Metadata about the uploaded file
+	 */
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	public addFile(file: File): Promise<UploadedFileMetadata> {
+		return Promise.reject(
+			new Error("Do not call MediaBackend directly: use a subclass")
+		);
+	}
+}
diff --git a/packages/media-manager/media-converter.ts b/packages/media-manager/media-converter.ts
new file mode 100644
index 00000000..2602f4cf
--- /dev/null
+++ b/packages/media-manager/media-converter.ts
@@ -0,0 +1,94 @@
+/**
+ * @packageDocumentation
+ * @module MediaManager
+ * @description Handles media conversion between formats
+ */
+import sharp from "sharp";
+
+export enum ConvertableMediaFormats {
+	PNG = "png",
+	WEBP = "webp",
+	JPEG = "jpeg",
+	JPG = "jpg",
+	AVIF = "avif",
+	JXL = "jxl",
+	HEIF = "heif",
+}
+
+/**
+ * Handles media conversion between formats
+ */
+export class MediaConverter {
+	constructor(
+		public fromFormat: ConvertableMediaFormats,
+		public toFormat: ConvertableMediaFormats
+	) {}
+
+	/**
+	 * Returns whether the media is convertable
+	 * @returns Whether the media is convertable
+	 */
+	public isConvertable() {
+		return (
+			this.fromFormat !== this.toFormat &&
+			Object.values(ConvertableMediaFormats).includes(this.fromFormat)
+		);
+	}
+
+	/**
+	 * Returns the file name with the extension replaced
+	 * @param fileName File name to replace
+	 * @returns File name with extension replaced
+	 */
+	private getReplacedFileName(fileName: string) {
+		return this.extractFilenameFromPath(fileName).replace(
+			new RegExp(`\\.${this.fromFormat}$`),
+			`.${this.toFormat}`
+		);
+	}
+
+	/**
+	 * Extracts the filename from a path
+	 * @param path Path to extract filename from
+	 * @returns Extracted filename
+	 */
+	private extractFilenameFromPath(path: string) {
+		// Don't count escaped slashes as path separators
+		const pathParts = path.split(/(?<!\\)\//);
+		return pathParts[pathParts.length - 1];
+	}
+
+	/**
+	 * Converts media to the specified format
+	 * @param media Media to convert
+	 * @returns Converted media
+	 */
+	public async convert(media: File) {
+		if (!this.isConvertable()) {
+			return media;
+		}
+
+		const sharpCommand = sharp(await media.arrayBuffer());
+
+		// Calculate newFilename before changing formats to prevent errors with jpg files
+		const newFilename = this.getReplacedFileName(media.name);
+
+		if (this.fromFormat === ConvertableMediaFormats.JPG) {
+			this.fromFormat = ConvertableMediaFormats.JPEG;
+		}
+
+		if (this.toFormat === ConvertableMediaFormats.JPG) {
+			this.toFormat = ConvertableMediaFormats.JPEG;
+		}
+
+		const convertedBuffer = await sharpCommand[this.toFormat]().toBuffer();
+
+		// Convert the buffer to a BlobPart
+		const buffer = new Blob([convertedBuffer]);
+
+		return new File([buffer], newFilename, {
+			type: `image/${this.toFormat}`,
+			lastModified: Date.now(),
+		});
+	}
+}
diff --git a/packages/media-manager/package.json b/packages/media-manager/package.json
new file mode 100644
index 00000000..67d5fd00
--- /dev/null
+++ b/packages/media-manager/package.json
@@ -0,0 +1,6 @@
+{
+  "name": "media-manager",
+  "version": "0.0.0",
+  "main": "index.ts",
+  "dependencies": { "@bradenmacdonald/s3-lite-client": "npm:@jsr/bradenmacdonald__s3-lite-client" }
+}
\ No newline at end of file
diff --git a/packages/media-manager/tests/media-backends.test.ts b/packages/media-manager/tests/media-backends.test.ts
new file mode 100644
index 00000000..3470927e
--- /dev/null
+++ b/packages/media-manager/tests/media-backends.test.ts
@@ -0,0 +1,276 @@
+// FILEPATH: /home/jessew/Dev/lysand/packages/media-manager/backends/s3.test.ts
+import { MediaBackend, MediaBackendType, MediaHasher } from "..";
+import type { S3Client } from "@bradenmacdonald/s3-lite-client";
+import { beforeEach, describe, jest, it, expect, spyOn } from "bun:test";
+import { S3MediaBackend } from "../backends/s3";
+import type { ConfigType } from "config-manager";
+import { ConvertableMediaFormats, MediaConverter } from "../media-converter";
+import { LocalMediaBackend } from "../backends/local";
+
+type DeepPartial<T> = {
+	[P in keyof T]?: DeepPartial<T[P]>;
+};
+
+describe("MediaBackend", () => {
+	let mediaBackend: MediaBackend;
+	let mockConfig: ConfigType;
+
+	beforeEach(() => {
+		mockConfig = {
+			media: {
+				conversion: {
+					convert_images: true,
+				},
+			},
+		} as ConfigType;
+		mediaBackend = new MediaBackend(mockConfig, MediaBackendType.S3);
+	});
+
+	it("should initialize with correct backend type", () => {
+		expect(mediaBackend.getBackendType()).toEqual(MediaBackendType.S3);
+	});
+
+	describe("fromBackendType", () => {
+		it("should return a LocalMediaBackend instance for LOCAL backend type", async () => {
+			const backend = await MediaBackend.fromBackendType(
+				MediaBackendType.LOCAL,
+				mockConfig
+			);
+			expect(backend).toBeInstanceOf(LocalMediaBackend);
+		});
+
+		it("should return a S3MediaBackend instance for S3 backend type", async () => {
+			const backend = await MediaBackend.fromBackendType(
+				MediaBackendType.S3,
+				{
+					s3: {
+						endpoint: "localhost:4566",
+						region: "us-east-1",
+						bucket_name: "test-bucket",
+						access_key: "test-access",
+						public_url: "test",
+						secret_access_key: "test-secret",
+					},
+				} as ConfigType
+			);
+			expect(backend).toBeInstanceOf(S3MediaBackend);
+		});
+
+		it("should throw an error for unknown backend type", () => {
+			expect(
+				MediaBackend.fromBackendType("unknown" as any, mockConfig)
+			).rejects.toThrow("Unknown backend type: unknown");
+		});
+	});
+
+	it("should check if images should be converted", () => {
+		expect(mediaBackend.shouldConvertImages(mockConfig)).toBe(true);
+		mockConfig.media.conversion.convert_images = false;
+		expect(mediaBackend.shouldConvertImages(mockConfig)).toBe(false);
+	});
+
+	it("should throw error when calling getFileByHash", () => {
+		const mockHash = "test-hash";
+		const databaseHashFetcher = jest.fn().mockResolvedValue("test.jpg");
+
+		expect(
+			mediaBackend.getFileByHash(mockHash, databaseHashFetcher)
+		).rejects.toThrow(Error);
+	});
+
+	it("should throw error when calling getFile", () => {
+		const mockFilename = "test.jpg";
+
+		expect(mediaBackend.getFile(mockFilename)).rejects.toThrow(Error);
+	});
+
+	it("should throw error when calling addFile", () => {
+		const mockFile = new File([""], "test.jpg");
+
+		expect(mediaBackend.addFile(mockFile)).rejects.toThrow();
+	});
+});
+
+describe("S3MediaBackend", () => {
+	let s3MediaBackend: S3MediaBackend;
+	let mockS3Client: Partial<S3Client>;
+	let mockConfig: DeepPartial<ConfigType>;
+	let mockFile: File;
+	let mockMediaHasher: MediaHasher;
+
+	beforeEach(() => {
+		mockConfig = {
+			s3: {
+				endpoint: "http://localhost:4566",
+				region: "us-east-1",
+				bucket_name: "test-bucket",
+				access_key: "test-access-key",
+				secret_access_key: "test-secret-access-key",
+				public_url: "test",
+			},
+			media: {
+				conversion: {
+					convert_to: ConvertableMediaFormats.PNG,
+				},
+			},
+		};
+		mockFile = new File([new TextEncoder().encode("test")], "test.jpg");
+		mockMediaHasher = new MediaHasher();
+		mockS3Client = {
+			putObject: jest.fn().mockResolvedValue({}),
+			statObject: jest.fn().mockResolvedValue({}),
+			getObject: jest.fn().mockResolvedValue({
+				blob: jest.fn().mockResolvedValue(new Blob()),
+				headers: new Headers({ "Content-Type": "image/jpeg" }),
+			}),
+		} as Partial<S3Client>;
+		s3MediaBackend = new S3MediaBackend(
+			mockConfig as ConfigType,
+			mockS3Client as S3Client
+		);
+	});
+
+	it("should initialize with correct type", () => {
+		expect(s3MediaBackend.getBackendType()).toEqual(MediaBackendType.S3);
+	});
+
+	it("should add file", async () => {
+		const mockHash = "test-hash";
+		spyOn(mockMediaHasher, "getMediaHash").mockResolvedValue(mockHash);
+
+		const result = await s3MediaBackend.addFile(mockFile);
+
+		expect(result.uploadedFile).toEqual(mockFile);
+		expect(result.hash).toHaveLength(64);
+		expect(mockS3Client.putObject).toHaveBeenCalledWith(
+			mockFile.name,
+			expect.any(ReadableStream),
+			{ size: mockFile.size }
+		);
+	});
+
+	it("should get file by hash", async () => {
+		const mockHash = "test-hash";
+		const mockFilename = "test.jpg";
+		const databaseHashFetcher = jest.fn().mockResolvedValue(mockFilename);
+		mockS3Client.statObject = jest.fn().mockResolvedValue({});
+		mockS3Client.getObject = jest.fn().mockResolvedValue({
+			arrayBuffer: jest.fn().mockResolvedValue(new ArrayBuffer(10)),
+			headers: new Headers({ "Content-Type": "image/jpeg" }),
+		});
+
+		const file = await s3MediaBackend.getFileByHash(
+			mockHash,
+			databaseHashFetcher
+		);
+
+		expect(file).not.toBeNull();
+		expect(file?.name).toEqual(mockFilename);
+		expect(file?.type).toEqual("image/jpeg");
+	});
+
+	it("should get file", async () => {
+		const mockFilename = "test.jpg";
+		mockS3Client.statObject = jest.fn().mockResolvedValue({});
+		mockS3Client.getObject = jest.fn().mockResolvedValue({
+			arrayBuffer: jest.fn().mockResolvedValue(new ArrayBuffer(10)),
+			headers: new Headers({ "Content-Type": "image/jpeg" }),
+		});
+
+		const file = await s3MediaBackend.getFile(mockFilename);
+
+		expect(file).not.toBeNull();
+		expect(file?.name).toEqual(mockFilename);
+		expect(file?.type).toEqual("image/jpeg");
+	});
+});
+
+describe("LocalMediaBackend", () => {
+	let localMediaBackend: LocalMediaBackend;
+	let mockConfig: ConfigType;
+	let mockFile: File;
+	let mockMediaHasher: MediaHasher;
+
+	beforeEach(() => {
+		mockConfig = {
+			media: {
+				conversion: {
+					convert_images: true,
+					convert_to: ConvertableMediaFormats.PNG,
+				},
+				local_uploads_folder: "./uploads",
+			},
+		} as ConfigType;
+		mockFile = Bun.file(__dirname + "/megamind.jpg") as unknown as File;
+		mockMediaHasher = new MediaHasher();
+		localMediaBackend = new LocalMediaBackend(mockConfig);
+	});
+
+	it("should initialize with correct type", () => {
+		expect(localMediaBackend.getBackendType()).toEqual(
+			MediaBackendType.LOCAL
+		);
+	});
+
+	it("should add file", async () => {
+		const mockHash = "test-hash";
+		spyOn(mockMediaHasher, "getMediaHash").mockResolvedValue(mockHash);
+		const mockMediaConverter = new MediaConverter(
+			ConvertableMediaFormats.JPG,
+			ConvertableMediaFormats.PNG
+		);
+		spyOn(mockMediaConverter, "convert").mockResolvedValue(mockFile);
+		// @ts-expect-error This is a mock
+		spyOn(Bun, "file").mockImplementationOnce(() => ({
+			exists: () => Promise.resolve(false),
+		}));
+		spyOn(Bun, "write").mockImplementationOnce(() =>
+			Promise.resolve(mockFile.size)
+		);
+
+		const result = await localMediaBackend.addFile(mockFile);
+
+		expect(result.uploadedFile).toEqual(mockFile);
+		expect(result.path).toEqual(`./uploads/megamind.png`);
+		expect(result.hash).toHaveLength(64);
+	});
+
+	it("should get file by hash", async () => {
+		const mockHash = "test-hash";
+		const mockFilename = "test.jpg";
+		const databaseHashFetcher = jest.fn().mockResolvedValue(mockFilename);
+		// @ts-expect-error This is a mock
+		spyOn(Bun, "file").mockImplementationOnce(() => ({
+			exists: () => Promise.resolve(true),
+			arrayBuffer: () => Promise.resolve(new ArrayBuffer(8)),
+			type: "image/jpeg",
+			lastModified: 123456789,
+		}));
+
+		const file = await localMediaBackend.getFileByHash(
+			mockHash,
+			databaseHashFetcher
+		);
+
+		expect(file).not.toBeNull();
+		expect(file?.name).toEqual(mockFilename);
+		expect(file?.type).toEqual("image/jpeg");
+	});
+
+	it("should get file", async () => {
+		const mockFilename = "test.jpg";
+		// @ts-expect-error This is a mock
+		spyOn(Bun, "file").mockImplementationOnce(() => ({
+			exists: () => Promise.resolve(true),
+			arrayBuffer: () => Promise.resolve(new ArrayBuffer(8)),
+			type: "image/jpeg",
+			lastModified: 123456789,
+		}));
+
+		const file = await localMediaBackend.getFile(mockFilename);
+
+		expect(file).not.toBeNull();
+		expect(file?.name).toEqual(mockFilename);
+		expect(file?.type).toEqual("image/jpeg");
+	});
+});
diff --git a/packages/media-manager/tests/media-manager.test.ts b/packages/media-manager/tests/media-manager.test.ts
new file mode 100644
index 00000000..017f3b6a
--- /dev/null
+++ b/packages/media-manager/tests/media-manager.test.ts
@@ -0,0 +1,65 @@
+// FILEPATH: /home/jessew/Dev/lysand/packages/media-manager/media-converter.test.ts
+import { describe, it, expect, beforeEach } from "bun:test";
+import { MediaConverter, ConvertableMediaFormats } from "../media-converter";
+
+describe("MediaConverter", () => {
+	let mediaConverter: MediaConverter;
+
+	beforeEach(() => {
+		mediaConverter = new MediaConverter(
+			ConvertableMediaFormats.JPG,
+			ConvertableMediaFormats.PNG
+		);
+	});
+
+	it("should initialize with correct formats", () => {
+		expect(mediaConverter.fromFormat).toEqual(ConvertableMediaFormats.JPG);
+		expect(mediaConverter.toFormat).toEqual(ConvertableMediaFormats.PNG);
+	});
+
+	it("should check if media is convertable", () => {
+		expect(mediaConverter.isConvertable()).toBe(true);
+		mediaConverter.toFormat = ConvertableMediaFormats.JPG;
+		expect(mediaConverter.isConvertable()).toBe(false);
+	});
+
+	it("should replace file name extension", () => {
+		const fileName = "test.jpg";
+		const expectedFileName = "test.png";
+		// Written like this because it's a private function
+		expect(mediaConverter["getReplacedFileName"](fileName)).toEqual(
+			expectedFileName
+		);
+	});
+
+	describe("Filename extractor", () => {
+		it("should extract filename from path", () => {
+			const path = "path/to/test.jpg";
+			const expectedFileName = "test.jpg";
+			expect(mediaConverter["extractFilenameFromPath"](path)).toEqual(
+				expectedFileName
+			);
+		});
+
+		it("should handle escaped slashes", () => {
+			const path = "path/to/test\\/test.jpg";
+			const expectedFileName = "test\\/test.jpg";
+			expect(mediaConverter["extractFilenameFromPath"](path)).toEqual(
+				expectedFileName
+			);
+		});
+	});
+
+	it("should convert media", async () => {
+		const file = Bun.file(__dirname + "/megamind.jpg");
+
+		const convertedFile = await mediaConverter.convert(
+			file as unknown as File
+		);
+
+		expect(convertedFile.name).toEqual("megamind.png");
+		expect(convertedFile.type).toEqual(
+			`image/${ConvertableMediaFormats.PNG}`
+		);
+	});
+});
diff --git a/packages/media-manager/tests/megamind.jpg b/packages/media-manager/tests/megamind.jpg
new file mode 100644
index 00000000..0f8f035a
Binary files /dev/null and b/packages/media-manager/tests/megamind.jpg differ
diff --git a/packages/request-parser/index.ts b/packages/request-parser/index.ts
new file mode 100644
index 00000000..6351fecc
--- /dev/null
+++ b/packages/request-parser/index.ts
@@ -0,0 +1,170 @@
+/**
+ * RequestParser
+ * @file index.ts
+ * @module request-parser
+ * @description Parses Request object into a JavaScript object based on the content type
+ */
+
+/**
+ * RequestParser
+ * Parses Request object into a JavaScript object
+ * based on the Content-Type header
+ * @param request Request object
+ * @returns JavaScript object of type T
+ */
+export class RequestParser {
+	constructor(public request: Request) {}
+
+	/**
+	 * Parse request body into a JavaScript object
+	 * @returns JavaScript object of type T
+	 * @throws Error if body is invalid
+	 */
+	async toObject<T>() {
+		try {
+			switch (await this.determineContentType()) {
+				case "application/json":
+					return this.parseJson<T>();
+				case "application/x-www-form-urlencoded":
+					return this.parseFormUrlencoded<T>();
+				case "multipart/form-data":
+					return this.parseFormData<T>();
+				default:
+					return this.parseQuery<T>();
+			}
+		} catch {
+			return {} as T;
+		}
+	}
+
+	/**
+	 * Determine body content type
+	 * If there is no Content-Type header, automatically
+	 * guess content type. Cuts off after ";" character
+	 * @returns Content-Type header value, or empty string if there is no body
+	 * @throws Error if body is invalid
+	 * @private
+	 */
+	private async determineContentType() {
+		if (this.request.headers.get("Content-Type")) {
+			return (
+				this.request.headers.get("Content-Type")?.split(";")[0] ?? ""
+			);
+		}
+
+		// Check if body is valid JSON
+		try {
+			await this.request.json();
+			return "application/json";
+		} catch {
+			// This is not JSON
+		}
+
+		// Check if body is valid FormData
+		try {
+			await this.request.formData();
+			return "multipart/form-data";
+		} catch {
+			// This is not FormData
+		}
+
+		if (this.request.body) {
+			throw new Error("Invalid body");
+		}
+
+		// If there is no body, return query parameters
+		return "";
+	}
+
+	/**
+	 * Parse FormData body into a JavaScript object
+	 * @returns JavaScript object of type T
+	 * @private
+	 * @throws Error if body is invalid
+	 */
+	private async parseFormData<T>(): Promise<Partial<T>> {
+		const formData = await this.request.formData();
+		const result: Partial<T> = {};
+
+		for (const [key, value] of formData.entries()) {
+			if (value instanceof File) {
+				result[key as keyof T] = value as any;
+			} else if (key.endsWith("[]")) {
+				const arrayKey = key.slice(0, -2) as keyof T;
+				if (!result[arrayKey]) {
+					result[arrayKey] = [] as T[keyof T];
+				}
+
+				(result[arrayKey] as any[]).push(value);
+			} else {
+				result[key as keyof T] = value as any;
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Parse application/x-www-form-urlencoded body into a JavaScript object
+	 * @returns JavaScript object of type T
+	 * @private
+	 * @throws Error if body is invalid
+	 */
+	private async parseFormUrlencoded<T>(): Promise<Partial<T>> {
+		const formData = await this.request.formData();
+		const result: Partial<T> = {};
+
+		for (const [key, value] of formData.entries()) {
+			if (key.endsWith("[]")) {
+				const arrayKey = key.slice(0, -2) as keyof T;
+				if (!result[arrayKey]) {
+					result[arrayKey] = [] as T[keyof T];
+				}
+
+				(result[arrayKey] as any[]).push(value);
+			} else {
+				result[key as keyof T] = value as any;
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Parse JSON body into a JavaScript object
+	 * @returns JavaScript object of type T
+	 * @private
+	 * @throws Error if body is invalid
+	 */
+	private async parseJson<T>(): Promise<Partial<T>> {
+		try {
+			return (await this.request.json()) as T;
+		} catch {
+			return {};
+		}
+	}
+
+	/**
+	 * Parse query parameters into a JavaScript object
+	 * @private
+	 * @throws Error if body is invalid
+	 * @returns JavaScript object of type T
+	 */
+	private parseQuery<T>(): Partial<T> {
+		const result: Partial<T> = {};
+		const url = new URL(this.request.url);
+
+		for (const [key, value] of url.searchParams.entries()) {
+			if (key.endsWith("[]")) {
+				const arrayKey = key.slice(0, -2) as keyof T;
+				if (!result[arrayKey]) {
+					result[arrayKey] = [] as T[keyof T];
+				}
+				(result[arrayKey] as string[]).push(value);
+			} else {
+				result[key as keyof T] = value as any;
+			}
+		}
+		return result;
+	}
+}
diff --git a/packages/request-parser/package.json b/packages/request-parser/package.json
new file mode 100644
index 00000000..89d30d2c
--- /dev/null
+++ b/packages/request-parser/package.json
@@ -0,0 +1,6 @@
+{
+    "name": "request-parser",
+    "version": "0.0.0",
+    "main": "index.ts",
+    "dependencies": {}
+}
\ No newline at end of file
diff --git a/packages/request-parser/tests/request-parser.test.ts b/packages/request-parser/tests/request-parser.test.ts
new file mode 100644
index 00000000..d6f4bf20
--- /dev/null
+++ b/packages/request-parser/tests/request-parser.test.ts
@@ -0,0 +1,158 @@
+import { describe, it, expect, test } from "bun:test";
+import { RequestParser } from "..";
+
+describe("RequestParser", () => {
+	describe("Should parse query parameters correctly", () => {
+		test("With text parameters", async () => {
+			const request = new Request(
+				"http://localhost?param1=value1&param2=value2"
+			);
+			const result = await new RequestParser(request).toObject<{
+				param1: string;
+				param2: string;
+			}>();
+			expect(result).toEqual({ param1: "value1", param2: "value2" });
+		});
+
+		test("With Array", async () => {
+			const request = new Request(
+				"http://localhost?test[]=value1&test[]=value2"
+			);
+			const result = await new RequestParser(request).toObject<{
+				test: string[];
+			}>();
+			expect(result.test).toEqual(["value1", "value2"]);
+		});
+
+		test("With both at once", async () => {
+			const request = new Request(
+				"http://localhost?param1=value1&param2=value2&test[]=value1&test[]=value2"
+			);
+			const result = await new RequestParser(request).toObject<{
+				param1: string;
+				param2: string;
+				test: string[];
+			}>();
+			expect(result).toEqual({
+				param1: "value1",
+				param2: "value2",
+				test: ["value1", "value2"],
+			});
+		});
+	});
+
+	it("should parse JSON body correctly", async () => {
+		const request = new Request("http://localhost", {
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ param1: "value1", param2: "value2" }),
+		});
+		const result = await new RequestParser(request).toObject<{
+			param1: string;
+			param2: string;
+		}>();
+		expect(result).toEqual({ param1: "value1", param2: "value2" });
+	});
+
+	it("should handle invalid JSON body", async () => {
+		const request = new Request("http://localhost", {
+			headers: { "Content-Type": "application/json" },
+			body: "invalid json",
+		});
+		const result = await new RequestParser(request).toObject<{
+			param1: string;
+			param2: string;
+		}>();
+		expect(result).toEqual({});
+	});
+
+	describe("should parse form data correctly", () => {
+		test("With basic text parameters", async () => {
+			const formData = new FormData();
+			formData.append("param1", "value1");
+			formData.append("param2", "value2");
+			const request = new Request("http://localhost", {
+				method: "POST",
+				body: formData,
+			});
+			const result = await new RequestParser(request).toObject<{
+				param1: string;
+				param2: string;
+			}>();
+			expect(result).toEqual({ param1: "value1", param2: "value2" });
+		});
+
+		test("With File object", async () => {
+			const file = new File(["content"], "filename.txt", {
+				type: "text/plain",
+			});
+			const formData = new FormData();
+			formData.append("file", file);
+			const request = new Request("http://localhost", {
+				method: "POST",
+				body: formData,
+			});
+			const result = await new RequestParser(request).toObject<{
+				file: File;
+			}>();
+			expect(result.file).toBeInstanceOf(File);
+			expect(await result.file?.text()).toEqual("content");
+		});
+
+		test("With Array", async () => {
+			const formData = new FormData();
+			formData.append("test[]", "value1");
+			formData.append("test[]", "value2");
+			const request = new Request("http://localhost", {
+				method: "POST",
+				body: formData,
+			});
+			const result = await new RequestParser(request).toObject<{
+				test: string[];
+			}>();
+			expect(result.test).toEqual(["value1", "value2"]);
+		});
+
+		test("With all three at once", async () => {
+			const file = new File(["content"], "filename.txt", {
+				type: "text/plain",
+			});
+			const formData = new FormData();
+			formData.append("param1", "value1");
+			formData.append("param2", "value2");
+			formData.append("file", file);
+			formData.append("test[]", "value1");
+			formData.append("test[]", "value2");
+			const request = new Request("http://localhost", {
+				method: "POST",
+				body: formData,
+			});
+			const result = await new RequestParser(request).toObject<{
+				param1: string;
+				param2: string;
+				file: File;
+				test: string[];
+			}>();
+			expect(result).toEqual({
+				param1: "value1",
+				param2: "value2",
+				file: file,
+				test: ["value1", "value2"],
+			});
+		});
+
+		test("URL Encoded", async () => {
+			const request = new Request("http://localhost", {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/x-www-form-urlencoded",
+				},
+				body: "param1=value1&param2=value2",
+			});
+			const result = await new RequestParser(request).toObject<{
+				param1: string;
+				param2: string;
+			}>();
+			expect(result).toEqual({ param1: "value1", param2: "value2" });
+		});
+	});
+});
diff --git a/pages/App.vue b/pages/App.vue
new file mode 100644
index 00000000..3b798503
--- /dev/null
+++ b/pages/App.vue
@@ -0,0 +1,10 @@
+<script setup>
+// Import Tailwind style reset
+import '@unocss/reset/tailwind-compat.css'
+</script>
+
+<template>
+    <suspense>
+        <router-view></router-view>
+    </suspense>
+</template>
\ No newline at end of file
diff --git a/pages/components/LoginInput.vue b/pages/components/LoginInput.vue
new file mode 100644
index 00000000..b1ed5123
--- /dev/null
+++ b/pages/components/LoginInput.vue
@@ -0,0 +1,30 @@
+<template>
+    <div class="flex items-center justify-between">
+        <label for="password" class="block text-sm font-medium leading-6 text-gray-900">{{ label }}</label>
+    </div>
+    <div class="mt-2">
+        <input v-bind="$attrs" @input="checkValid" :class="['block w-full rounded-md border-0 py-1.5 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-indigo-600 sm:text-sm sm:leading-6',
+            (isInvalid || error) && 'invalid:!ring-red-600 invalid:ring-2']">
+        <span v-if="isInvalid || error" class="mt-1 text-xs text-red-600">{{ error ? error : `${label} is invalid` }}</span>
+    </div>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue';
+
+const props = defineProps<{
+    label: string;
+    error?: string;
+}>();
+
+const isInvalid = ref(false);
+
+const checkValid = (e: Event) => {
+    const target = e.target as HTMLInputElement;
+    if (target.checkValidity()) {
+        isInvalid.value = false;
+    } else {
+        isInvalid.value = true;
+    }
+}
+</script>
\ No newline at end of file
diff --git a/pages/favicon.png b/pages/favicon.png
new file mode 100644
index 00000000..c56caef9
Binary files /dev/null and b/pages/favicon.png differ
diff --git a/pages/index.html b/pages/index.html
new file mode 100644
index 00000000..5a0ba2d4
--- /dev/null
+++ b/pages/index.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/png" href="/favicon.png" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Lysand</title>
+</head>
+
+<body>
+    <div id="app"></div>
+    <script type="module" src="./main.ts"></script>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/pages/login.html b/pages/login.html
deleted file mode 100644
index 4eb3abf5..00000000
--- a/pages/login.html
+++ /dev/null
@@ -1,445 +0,0 @@
-<!DOCTYPE html>
-
-<head>
-	<title>Login with Lysand</title>
-	{{STYLES}}
-	<style>
-		/*
-1. Prevent padding and border from affecting element width. (https://github.com/mozdevs/cssremedy/issues/4)
-2. Allow adding a border to an element by just adding a border-width. (https://github.com/tailwindcss/tailwindcss/pull/116)
-2. [UnoCSS]: allow to override the default border color with css var `--un-default-border-color`
-*/
-
-		*,
-		::before,
-		::after {
-			box-sizing: border-box;
-			/* 1 */
-			border-width: 0;
-			/* 2 */
-			border-style: solid;
-			/* 2 */
-			border-color: var(--un-default-border-color, #e5e7eb);
-			/* 2 */
-		}
-
-		/*
-1. Use a consistent sensible line-height in all browsers.
-2. Prevent adjustments of font size after orientation changes in iOS.
-3. Use a more readable tab size.
-4. Use the user's configured `sans` font-family by default.
-*/
-
-		html {
-			line-height: 1.5;
-			/* 1 */
-			-webkit-text-size-adjust: 100%;
-			/* 2 */
-			text-size-adjust: 100%;
-			/* 2 */
-			-moz-tab-size: 4;
-			/* 3 */
-			tab-size: 4;
-			/* 3 */
-			font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
-			/* 4 */
-		}
-
-		/*
-1. Remove the margin in all browsers.
-2. Inherit line-height from `html` so users can set them as a class directly on the `html` element.
-*/
-
-		body {
-			margin: 0;
-			/* 1 */
-			line-height: inherit;
-			/* 2 */
-		}
-
-		/*
-1. Add the correct height in Firefox.
-2. Correct the inheritance of border color in Firefox. (https://bugzilla.mozilla.org/show_bug.cgi?id=190655)
-3. Ensure horizontal rules are visible by default.
-*/
-
-		hr {
-			height: 0;
-			/* 1 */
-			color: inherit;
-			/* 2 */
-			border-top-width: 1px;
-			/* 3 */
-		}
-
-		/*
-Add the correct text decoration in Chrome, Edge, and Safari.
-*/
-
-		abbr:where([title]) {
-			text-decoration: underline dotted;
-		}
-
-		/*
-Remove the default font size and weight for headings.
-*/
-
-		h1,
-		h2,
-		h3,
-		h4,
-		h5,
-		h6 {
-			font-size: inherit;
-			font-weight: inherit;
-		}
-
-		/*
-Reset links to optimize for opt-in styling instead of opt-out.
-*/
-
-		a {
-			color: inherit;
-			text-decoration: inherit;
-		}
-
-		/*
-Add the correct font weight in Edge and Safari.
-*/
-
-		b,
-		strong {
-			font-weight: bolder;
-		}
-
-		/*
-1. Use the user's configured `mono` font family by default.
-2. Correct the odd `em` font sizing in all browsers.
-*/
-
-		code,
-		kbd,
-		samp,
-		pre {
-			font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
-			/* 1 */
-			font-size: 1em;
-			/* 2 */
-		}
-
-		/*
-Add the correct font size in all browsers.
-*/
-
-		small {
-			font-size: 80%;
-		}
-
-		/*
-Prevent `sub` and `sup` elements from affecting the line height in all browsers.
-*/
-
-		sub,
-		sup {
-			font-size: 75%;
-			line-height: 0;
-			position: relative;
-			vertical-align: baseline;
-		}
-
-		sub {
-			bottom: -0.25em;
-		}
-
-		sup {
-			top: -0.5em;
-		}
-
-		/*
-1. Remove text indentation from table contents in Chrome and Safari. (https://bugs.chromium.org/p/chromium/issues/detail?id=999088, https://bugs.webkit.org/show_bug.cgi?id=201297)
-2. Correct table border color inheritance in all Chrome and Safari. (https://bugs.chromium.org/p/chromium/issues/detail?id=935729, https://bugs.webkit.org/show_bug.cgi?id=195016)
-3. Remove gaps between table borders by default.
-*/
-
-		table {
-			text-indent: 0;
-			/* 1 */
-			border-color: inherit;
-			/* 2 */
-			border-collapse: collapse;
-			/* 3 */
-		}
-
-		/*
-1. Change the font styles in all browsers.
-2. Remove the margin in Firefox and Safari.
-3. Remove default padding in all browsers.
-*/
-
-		button,
-		input,
-		optgroup,
-		select,
-		textarea {
-			font-family: inherit;
-			/* 1 */
-			font-feature-settings: inherit;
-			/* 1 */
-			font-variation-settings: inherit;
-			/* 1 */
-			font-size: 100%;
-			/* 1 */
-			font-weight: inherit;
-			/* 1 */
-			line-height: inherit;
-			/* 1 */
-			color: inherit;
-			/* 1 */
-			margin: 0;
-			/* 2 */
-			padding: 0;
-			/* 3 */
-		}
-
-		/*
-Remove the inheritance of text transform in Edge and Firefox.
-*/
-
-		button,
-		select {
-			text-transform: none;
-		}
-
-		/*
-1. Correct the inability to style clickable types in iOS and Safari.
-2. Remove default button styles.
-*/
-
-		button,
-		[type='button'],
-		[type='reset'],
-		[type='submit'] {
-			-webkit-appearance: button;
-			/* 1 */
-			background-color: transparent;
-			/* 2 */
-			background-image: none;
-			/* 2 */
-		}
-
-		/*
-Use the modern Firefox focus style for all focusable elements.
-*/
-
-		:-moz-focusring {
-			outline: auto;
-		}
-
-		/*
-Remove the additional `:invalid` styles in Firefox. (https://github.com/mozilla/gecko-dev/blob/2f9eacd9d3d995c937b4251a5557d95d494c9be1/layout/style/res/forms.css#L728-L737)
-*/
-
-		:-moz-ui-invalid {
-			box-shadow: none;
-		}
-
-		/*
-Add the correct vertical alignment in Chrome and Firefox.
-*/
-
-		progress {
-			vertical-align: baseline;
-		}
-
-		/*
-Correct the cursor style of increment and decrement buttons in Safari.
-*/
-
-		::-webkit-inner-spin-button,
-		::-webkit-outer-spin-button {
-			height: auto;
-		}
-
-		/*
-1. Correct the odd appearance in Chrome and Safari.
-2. Correct the outline style in Safari.
-*/
-
-		[type='search'] {
-			-webkit-appearance: textfield;
-			/* 1 */
-			outline-offset: -2px;
-			/* 2 */
-		}
-
-		/*
-Remove the inner padding in Chrome and Safari on macOS.
-*/
-
-		::-webkit-search-decoration {
-			-webkit-appearance: none;
-		}
-
-		/*
-1. Correct the inability to style clickable types in iOS and Safari.
-2. Change font properties to `inherit` in Safari.
-*/
-
-		::-webkit-file-upload-button {
-			-webkit-appearance: button;
-			/* 1 */
-			font: inherit;
-			/* 2 */
-		}
-
-		/*
-Add the correct display in Chrome and Safari.
-*/
-
-		summary {
-			display: list-item;
-		}
-
-		/*
-Removes the default spacing and border for appropriate elements.
-*/
-
-		blockquote,
-		dl,
-		dd,
-		h1,
-		h2,
-		h3,
-		h4,
-		h5,
-		h6,
-		hr,
-		figure,
-		p,
-		pre {
-			margin: 0;
-		}
-
-		fieldset {
-			margin: 0;
-			padding: 0;
-		}
-
-		legend {
-			padding: 0;
-		}
-
-		ol,
-		ul,
-		menu {
-			list-style: none;
-			margin: 0;
-			padding: 0;
-		}
-
-		/*
-Prevent resizing textareas horizontally by default.
-*/
-
-		textarea {
-			resize: vertical;
-		}
-
-		/*
-1. Reset the default placeholder opacity in Firefox. (https://github.com/tailwindlabs/tailwindcss/issues/3300)
-2. Set the default placeholder color to the user's configured gray 400 color.
-*/
-
-		input::placeholder,
-		textarea::placeholder {
-			opacity: 1;
-			/* 1 */
-			color: #9ca3af;
-			/* 2 */
-		}
-
-		/*
-Set the default cursor for buttons.
-*/
-
-		button,
-		[role="button"] {
-			cursor: pointer;
-		}
-
-		/*
-Make sure disabled buttons don't get the pointer cursor.
-*/
-		:disabled {
-			cursor: default;
-		}
-
-		/*
-1. Make replaced elements `display: block` by default. (https://github.com/mozdevs/cssremedy/issues/14)
-2. Add `vertical-align: middle` to align replaced elements more sensibly by default. (https://github.com/jensimmons/cssremedy/issues/14#issuecomment-634934210)
-   This can trigger a poorly considered lint error in some tools but is included by design.
-*/
-
-		img,
-		svg,
-		video,
-		canvas,
-		audio,
-		iframe,
-		embed,
-		object {
-			display: block;
-			/* 1 */
-			vertical-align: middle;
-			/* 2 */
-		}
-
-		/*
-Constrain images and videos to the parent width and preserve their intrinsic aspect ratio. (https://github.com/mozdevs/cssremedy/issues/14)
-*/
-
-		img,
-		video {
-			max-width: 100%;
-			height: auto;
-		}
-
-		/* Make elements with the HTML hidden attribute stay hidden by default */
-		[hidden] {
-			display: none;
-		}
-	</style>
-	<meta charset="utf-8">
-</head>
-
-<body>
-	<div class="flex min-h-screen flex-col justify-center px-6 py-12 lg:px-8">
-		<div class="mt-10 sm:mx-auto sm:w-full sm:max-w-sm">
-			<form class="space-y-6" method="POST" action="{{URL}}">
-				<div>
-					<label for="email" class="block text-sm font-medium leading-6 text-gray-900">Email address</label>
-					<div class="mt-2">
-						<input id="email" name="email" type="email" autocomplete="email" required
-							class="block w-full rounded-md border-0 py-1.5 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-indigo-600 sm:text-sm sm:leading-6">
-					</div>
-				</div>
-
-				<div>
-					<div class="flex items-center justify-between">
-						<label for="password" class="block text-sm font-medium leading-6 text-gray-900">Password</label>
-					</div>
-					<div class="mt-2">
-						<input id="password" name="password" type="password" autocomplete="current-password" required
-							class="block w-full rounded-md border-0 py-1.5 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-indigo-600 sm:text-sm sm:leading-6">
-					</div>
-				</div>
-
-				<div>
-					<button type="submit"
-						class="flex w-full justify-center rounded-md !bg-indigo-600 px-3 py-1.5 text-sm font-semibold leading-6 text-white shadow-sm hover:!bg-indigo-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-indigo-600">Sign
-						in</button>
-				</div>
-			</form>
-		</div>
-	</div>
-</body>
\ No newline at end of file
diff --git a/pages/main.ts b/pages/main.ts
new file mode 100644
index 00000000..92f1b4c5
--- /dev/null
+++ b/pages/main.ts
@@ -0,0 +1,16 @@
+import { createApp } from "vue";
+import "./style.css";
+import "virtual:uno.css";
+import { createRouter, createWebHistory } from "vue-router";
+import App from "./App.vue";
+import routes from "./routes";
+
+const router = createRouter({
+	history: createWebHistory(),
+	routes: routes,
+});
+
+const app = createApp(App);
+app.use(router);
+
+app.mount("#app");
diff --git a/pages/pages/index.vue b/pages/pages/index.vue
new file mode 100644
index 00000000..0c65d837
--- /dev/null
+++ b/pages/pages/index.vue
@@ -0,0 +1,44 @@
+<template>
+    <div class="bg-white">
+        <div class="relative isolate px-6 pt-14 lg:px-8">
+            <div class="absolute inset-x-0 -top-40 -z-10 transform-gpu overflow-hidden blur-3xl sm:-top-80"
+                aria-hidden="true">
+                <div class="relative left-[calc(50%-11rem)] aspect-[1155/678] w-[36.125rem] -translate-x-1/2 rotate-[30deg] bg-gradient-to-tr from-[#ff80b5] to-[#9089fc] opacity-30 sm:left-[calc(50%-30rem)] sm:w-[72.1875rem]"
+                    style="clip-path: polygon(74.1% 44.1%, 100% 61.6%, 97.5% 26.9%, 85.5% 0.1%, 80.7% 2%, 72.5% 32.5%, 60.2% 62.4%, 52.4% 68.1%, 47.5% 58.3%, 45.2% 34.5%, 27.5% 76.7%, 0.1% 64.9%, 17.9% 100%, 27.6% 76.8%, 76.1% 97.7%, 74.1% 44.1%)" />
+            </div>
+            <div class="mx-auto max-w-2xl py-32 sm:py-48 lg:py-56">
+                <div class="hidden sm:mb-8 sm:flex sm:justify-center">
+                    <div
+                        class="relative rounded px-3 py-1 text-sm leading-6 text-gray-600 ring-1 ring-gray-900/10 hover:ring-gray-900/20">
+                        You are using <a href="#" class="font-semibold text-indigo-600">Lysand {{ version }}</a>
+                    </div>
+                </div>
+                <div class="text-center">
+                    <h1 class="text-4xl font-bold tracking-tight text-gray-900 sm:text-6xl">Welcome to Lysand</h1>
+                    <p class="mt-6 text-lg leading-8 text-gray-600">You can login to this server by pointing any Mastodon
+                        client at <strong class="font-bold">{{ location.host }}</strong></p>
+                    <div class="mt-10 flex items-center justify-center gap-6 md:flex-row flex-col">
+                        <a href="https://github.com/lysand-org/lysand" target="_blank"
+                            class="rounded-md w-full bg-indigo-600 ring-indigo-600 ring-2 px-3.5 py-2.5 text-sm font-semibold text-white shadow-sm hover:bg-indigo-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-indigo-600">Read
+                            the docs</a>
+                        <a href="https://lysand.org" target="_blank"
+                            class="rounded-md w-full ring-indigo-600 ring-2 bg-white px-3.5 py-2.5 text-sm font-semibold text-indigo-500 shadow-sm hover:bg-gray-200 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-indigo-600">About
+                            the Lysand Protocol</a>
+                    </div>
+                </div>
+            </div>
+            <div class="absolute inset-x-0 top-[calc(100%-13rem)] -z-10 transform-gpu overflow-hidden blur-3xl sm:top-[calc(100%-30rem)]"
+                aria-hidden="true">
+                <div class="relative left-[calc(50%+3rem)] aspect-[1155/678] w-[36.125rem] -translate-x-1/2 bg-gradient-to-tr from-[#ff80b5] to-[#9089fc] opacity-30 sm:left-[calc(50%+36rem)] sm:w-[72.1875rem]"
+                    style="clip-path: polygon(74.1% 44.1%, 100% 61.6%, 97.5% 26.9%, 85.5% 0.1%, 80.7% 2%, 72.5% 32.5%, 60.2% 62.4%, 52.4% 68.1%, 47.5% 58.3%, 45.2% 34.5%, 27.5% 76.7%, 0.1% 64.9%, 17.9% 100%, 27.6% 76.8%, 76.1% 97.7%, 74.1% 44.1%)" />
+            </div>
+        </div>
+    </div>
+</template>
+  
+<script setup>
+import { ref } from 'vue';
+
+const location = window.location;
+const version = __VERSION__;
+</script>
\ No newline at end of file
diff --git a/pages/pages/oauth/authorize.vue b/pages/pages/oauth/authorize.vue
new file mode 100644
index 00000000..a4aac9f1
--- /dev/null
+++ b/pages/pages/oauth/authorize.vue
@@ -0,0 +1,79 @@
+<template>
+	<div class="flex min-h-screen relative flex-col justify-center px-6 py-12 lg:px-8">
+		<div class="absolute inset-x-0 -top-40 -z-10 transform-gpu overflow-hidden blur-3xl sm:-top-80" aria-hidden="true">
+			<div class="relative left-[calc(50%-11rem)] aspect-[1155/678] w-[36.125rem] -translate-x-1/2 rotate-[30deg] bg-gradient-to-tr from-[#ff80b5] to-[#9089fc] opacity-30 sm:left-[calc(50%-30rem)] sm:w-[72.1875rem]"
+				style="clip-path: polygon(74.1% 44.1%, 100% 61.6%, 97.5% 26.9%, 85.5% 0.1%, 80.7% 2%, 72.5% 32.5%, 60.2% 62.4%, 52.4% 68.1%, 47.5% 58.3%, 45.2% 34.5%, 27.5% 76.7%, 0.1% 64.9%, 17.9% 100%, 27.6% 76.8%, 76.1% 97.7%, 74.1% 44.1%)" />
+		</div>
+		<div class="mt-10 sm:mx-auto sm:w-full sm:max-w-sm">
+			<form class="space-y-6" method="POST"
+				:action="`/auth/login?redirect_uri=${redirect_uri}&response_type=${response_type}&client_id=${client_id}&scope=${scope}`">
+				<div>
+					<h1 class="font-bold text-2xl text-center tracking-tight">Login to your account</h1>
+				</div>
+
+				<div v-if="error && error !== 'undefined'" class="rounded bg-purple-100 ring-1 ring-purple-800 py-2 px-4">
+					<h3 class="font-bold">An error occured:</h3>
+					<p>{{ error }}</p>
+				</div>
+
+				<div>
+					<LoginInput label="Email" id="email" name="email" type="email" autocomplete="email" required />
+				</div>
+
+				<div>
+					<LoginInput label="Password" id="password" name="password" type="password"
+						autocomplete="current-password" required />
+				</div>
+
+				<div v-if="oauthProviders && oauthProviders.length > 0" class="w-full flex flex-col gap-3">
+					<h2 class="text-sm text-gray-700">Or sign in with</h2>
+					<div class="grid grid-cols-2 gap-4 w-full">
+						<a v-for="provider of oauthProviders" :key="provider.id"
+							:href="`/oauth/authorize-external?issuer=${provider.id}&redirect_uri=${redirect_uri}&response_type=${response_type}&clientId=${client_id}&scope=${scope}`"
+							class="flex flex-row justify-center rounded ring-1 gap-2 p-2 ring-black/10 hover:shadow duration-200">
+							<img :src="provider.icon" :alt="provider.name" class="w-6 h-6" />
+							<div class="flex flex-col gap-0 justify-center">
+								<h3 class="font-bold">{{ provider.name }}</h3>
+							</div>
+						</a>
+					</div>
+				</div>
+
+				<div>
+					<button type="submit"
+						class="flex w-full justify-center rounded-md bg-purple-600 px-3 py-1.5 text-sm font-semibold leading-6 text-white shadow-sm hover:shadow-lg duration-200 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-indigo-600">Sign
+						in</button>
+				</div>
+			</form>
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { useRoute } from 'vue-router';
+import LoginInput from "../../components/LoginInput.vue"
+import { onMounted, ref } from 'vue';
+
+const query = useRoute().query;
+
+const redirect_uri = query.redirect_uri;
+const response_type = query.response_type;
+const client_id = query.client_id;
+const scope = query.scope;
+const error = decodeURIComponent(query.error as string);
+
+const oauthProviders = ref<{
+	name: string;
+	icon: string;
+	id: string
+}[] | null>(null);
+
+const getOauthProviders = async () => {
+	const response = await fetch('/oauth/providers');
+	return await response.json() as any;
+}
+
+onMounted(async () => {
+	oauthProviders.value = await getOauthProviders();
+})
+</script>
\ No newline at end of file
diff --git a/pages/pages/register/index.vue b/pages/pages/register/index.vue
new file mode 100644
index 00000000..731e579f
--- /dev/null
+++ b/pages/pages/register/index.vue
@@ -0,0 +1,149 @@
+<template>
+    <div class="flex min-h-screen flex-col justify-center px-6 py-12 lg:px-8 relative">
+        <div class="absolute inset-x-0 -top-40 -z-10 transform-gpu overflow-hidden blur-3xl sm:-top-80" aria-hidden="true">
+            <div class="relative left-[calc(50%-11rem)] aspect-[1155/678] w-[36.125rem] -translate-x-1/2 rotate-[30deg] bg-gradient-to-tr from-[#ff80b5] to-[#9089fc] opacity-30 sm:left-[calc(50%-30rem)] sm:w-[72.1875rem]"
+                style="clip-path: polygon(74.1% 44.1%, 100% 61.6%, 97.5% 26.9%, 85.5% 0.1%, 80.7% 2%, 72.5% 32.5%, 60.2% 62.4%, 52.4% 68.1%, 47.5% 58.3%, 45.2% 34.5%, 27.5% 76.7%, 0.1% 64.9%, 17.9% 100%, 27.6% 76.8%, 76.1% 97.7%, 74.1% 44.1%)" />
+        </div>
+        <div v-if="instanceInfo.registrations" class="mt-10 sm:mx-auto sm:w-full sm:max-w-sm">
+            <form ref="form" class="space-y-6" method="POST" action="" @submit.prevent="registerUser">
+                <div>
+                    <h1 class="font-bold text-2xl text-center tracking-tight">Register for an account</h1>
+                </div>
+
+                <div>
+                    <LoginInput label="Email" id="email" name="email" type="email" autocomplete="email" required />
+                </div>
+
+                <div v-if="errors['email']" v-for="error of errors['email']"
+                    class="rounded bg-purple-100 ring-1 ring-purple-800 py-2 px-4">
+                    <h3 class="font-bold">An error occured:</h3>
+                    <p>{{ error.description }}</p>
+                </div>
+
+                <div>
+                    <LoginInput label="Username" id="username" name="username" type="text" autocomplete="username"
+                        required />
+                </div>
+
+                <div v-if="errors['username']" v-for="error of errors['username']"
+                    class="rounded bg-purple-100 ring-1 ring-purple-800 py-2 px-4">
+                    <h3 class="font-bold">An error occured:</h3>
+                    <p>{{ error.description }}</p>
+                </div>
+
+                <div>
+                    <LoginInput label="Password" id="password" name="password" type="password" autocomplete="" required
+                        :spellcheck="false" :error="!passwordsMatch ? `Passwords dont match` : ``" :value="password1"
+                        @input="password1 = $event.target.value" />
+                </div>
+
+                <div v-if="errors['password']" v-for="error of errors['password']"
+                    class="rounded bg-purple-100 ring-1 ring-purple-800 py-2 px-4">
+                    <h3 class="font-bold">An error occured:</h3>
+                    <p>{{ error.description }}</p>
+                </div>
+
+                <div>
+                    <LoginInput label="Confirm password" id="password2" name="password2" type="password" autocomplete=""
+                        required :spellcheck="false" :error="!passwordsMatch ? `Passwords dont match` : ``"
+                        :value="password2" @input="password2 = $event.target.value" />
+                </div>
+
+                <div>
+                    <label for="comment" class="block text-sm font-medium leading-6 text-gray-900">Why do you want to
+                        join?</label>
+                    <div class="mt-2">
+                        <textarea rows="4" required :value="reason" @input="reason = ($event.target as any).value"
+                            name="comment" id="comment"
+                            class="block w-full rounded-md px-2 border-0 py-1.5 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-indigo-600 sm:text-sm sm:leading-6" />
+                    </div>
+                </div>
+
+                <div v-if="errors['reason']" v-for="error of errors['reason']"
+                    class="rounded bg-purple-100 ring-1 ring-purple-800 py-2 px-4">
+                    <h3 class="font-bold">An error occured:</h3>
+                    <p>{{ error.description }}</p>
+                </div>
+
+                <div class="">
+                    <input type="checkbox" :value="tosAccepted" @input="tosAccepted = Boolean(($event.target as any).value)"
+                        class="rounded mr-1 align-middle mb-0.5" /> <span class="text-sm">I agree to the
+                        terms and
+                        conditions
+                        of this
+                        server, available <a class="underline font-bold" target="_blank"
+                            :href="instanceInfo.tos_url">here</a></span>
+                </div>
+
+                <div v-if="errors['agreement']" v-for="error of errors['agreement']"
+                    class="rounded bg-purple-100 ring-1 ring-purple-800 py-2 px-4">
+                    <h3 class="font-bold">An error occured:</h3>
+                    <p>{{ error.description }}</p>
+                </div>
+
+                <div>
+                    <button type="submit" :disabled="!passwordsMatch || !tosAccepted"
+                        class="flex w-full justify-center disabled:opacity-50 disabled:hover:shadow-none rounded-md bg-purple-600 px-3 py-1.5 text-sm font-semibold leading-6 text-white shadow-sm hover:shadow-lg duration-200 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-indigo-600">Sign
+                        in</button>
+                </div>
+            </form>
+        </div>
+        <div v-else>
+            <h1 class="text-2xl font-bold tracking-tight text-gray-900 sm:text-4xl text-center">Registrations are disabled
+            </h1>
+            <p class="mt-6 text-lg leading-8 text-gray-600 text-center">Ask this instance's admin to enable them in config!
+            </p>
+        </div>
+    </div>
+</template>
+
+<script setup lang="ts">
+import type { APIInstance } from "~types/entities/instance";
+import LoginInput from "../../components/LoginInput.vue"
+import { computed, ref, watch } from 'vue';
+
+const instanceInfo = await fetch("/api/v1/instance").then(res => res.json()) as APIInstance & {
+    tos_url: string
+};
+
+const errors = ref<{
+    [key: string]: {
+        error: string;
+        description: string;
+    }[];
+}>({});
+
+const password1 = ref<string>("");
+const password2 = ref<string>("");
+const tosAccepted = ref<boolean>(false);
+const reason = ref<string>("");
+
+const passwordsMatch = computed(() => password1.value === password2.value);
+
+const registerUser = (e: Event) => {
+    e.preventDefault();
+    const formData = new FormData();
+
+    formData.append("email", (e.target as any).email.value);
+    formData.append("password", (e.target as any).password.value);
+    formData.append("username", (e.target as any).username.value);
+    formData.append("reason", reason.value);
+    formData.append("locale", "en")
+    formData.append("agreement", "true");
+    // @ts-ignore
+    fetch("/api/v1/accounts", {
+        method: "POST",
+        body: formData,
+    }).then(async res => {
+        if (res.status === 422) {
+            errors.value = (await res.json() as any).details;
+            console.log(errors.value)
+        } else {
+            // @ts-ignore
+            window.location.href = "/register/success";
+        }
+    }).catch(async err => {
+        console.error(err);
+    })
+}
+</script>
\ No newline at end of file
diff --git a/pages/pages/register/success.vue b/pages/pages/register/success.vue
new file mode 100644
index 00000000..6575fa04
--- /dev/null
+++ b/pages/pages/register/success.vue
@@ -0,0 +1,14 @@
+<template>
+    <div class="flex min-h-screen flex-col justify-center px-6 py-12 lg:px-8 relative">
+        <div class="absolute inset-x-0 -top-40 -z-10 transform-gpu overflow-hidden blur-3xl sm:-top-80" aria-hidden="true">
+            <div class="relative left-[calc(50%-11rem)] aspect-[1155/678] w-[36.125rem] -translate-x-1/2 rotate-[30deg] bg-gradient-to-tr from-[#ff80b5] to-[#9089fc] opacity-30 sm:left-[calc(50%-30rem)] sm:w-[72.1875rem]"
+                style="clip-path: polygon(74.1% 44.1%, 100% 61.6%, 97.5% 26.9%, 85.5% 0.1%, 80.7% 2%, 72.5% 32.5%, 60.2% 62.4%, 52.4% 68.1%, 47.5% 58.3%, 45.2% 34.5%, 27.5% 76.7%, 0.1% 64.9%, 17.9% 100%, 27.6% 76.8%, 76.1% 97.7%, 74.1% 44.1%)" />
+        </div>
+        <div>
+            <h1 class="text-2xl font-bold tracking-tight text-gray-900 sm:text-4xl text-center">Registration was a success!
+            </h1>
+            <p class="mt-6 text-lg leading-8 text-gray-600 text-center"> You can now login to your account in any Mastodon
+                client </p>
+        </div>
+    </div>
+</template>
\ No newline at end of file
diff --git a/pages/routes.ts b/pages/routes.ts
new file mode 100644
index 00000000..a39340ef
--- /dev/null
+++ b/pages/routes.ts
@@ -0,0 +1,12 @@
+import type { RouteRecordRaw } from "vue-router";
+import indexVue from "./pages/index.vue";
+import authorizeVue from "./pages/oauth/authorize.vue";
+import registerIndexVue from "./pages/register/index.vue";
+import successVue from "./pages/register/success.vue";
+
+export default [
+	{ path: "/", component: indexVue },
+	{ path: "/oauth/authorize", component: authorizeVue },
+	{ path: "/register", component: registerIndexVue },
+	{ path: "/register/success", component: successVue },
+] as RouteRecordRaw[];
diff --git a/pages/style.css b/pages/style.css
new file mode 100644
index 00000000..e69de29b
diff --git a/pages/uno.css b/pages/uno.css
deleted file mode 100644
index 4e3b1a12..00000000
--- a/pages/uno.css
+++ /dev/null
@@ -1,155 +0,0 @@
-/* layer: preflights */
-*,::before,::after{--un-rotate:0;--un-rotate-x:0;--un-rotate-y:0;--un-rotate-z:0;--un-scale-x:1;--un-scale-y:1;--un-scale-z:1;--un-skew-x:0;--un-skew-y:0;--un-translate-x:0;--un-translate-y:0;--un-translate-z:0;--un-pan-x: ;--un-pan-y: ;--un-pinch-zoom: ;--un-scroll-snap-strictness:proximity;--un-ordinal: ;--un-slashed-zero: ;--un-numeric-figure: ;--un-numeric-spacing: ;--un-numeric-fraction: ;--un-border-spacing-x:0;--un-border-spacing-y:0;--un-ring-offset-shadow:0 0 rgba(0,0,0,0);--un-ring-shadow:0 0 rgba(0,0,0,0);--un-shadow-inset: ;--un-shadow:0 0 rgba(0,0,0,0);--un-ring-inset: ;--un-ring-offset-width:0px;--un-ring-offset-color:#fff;--un-ring-width:0px;--un-ring-color:rgba(147,197,253,0.5);--un-blur: ;--un-brightness: ;--un-contrast: ;--un-drop-shadow: ;--un-grayscale: ;--un-hue-rotate: ;--un-invert: ;--un-saturate: ;--un-sepia: ;--un-backdrop-blur: ;--un-backdrop-brightness: ;--un-backdrop-contrast: ;--un-backdrop-grayscale: ;--un-backdrop-hue-rotate: ;--un-backdrop-invert: ;--un-backdrop-opacity: ;--un-backdrop-saturate: ;--un-backdrop-sepia: ;}::backdrop{--un-rotate:0;--un-rotate-x:0;--un-rotate-y:0;--un-rotate-z:0;--un-scale-x:1;--un-scale-y:1;--un-scale-z:1;--un-skew-x:0;--un-skew-y:0;--un-translate-x:0;--un-translate-y:0;--un-translate-z:0;--un-pan-x: ;--un-pan-y: ;--un-pinch-zoom: ;--un-scroll-snap-strictness:proximity;--un-ordinal: ;--un-slashed-zero: ;--un-numeric-figure: ;--un-numeric-spacing: ;--un-numeric-fraction: ;--un-border-spacing-x:0;--un-border-spacing-y:0;--un-ring-offset-shadow:0 0 rgba(0,0,0,0);--un-ring-shadow:0 0 rgba(0,0,0,0);--un-shadow-inset: ;--un-shadow:0 0 rgba(0,0,0,0);--un-ring-inset: ;--un-ring-offset-width:0px;--un-ring-offset-color:#fff;--un-ring-width:0px;--un-ring-color:rgba(147,197,253,0.5);--un-blur: ;--un-brightness: ;--un-contrast: ;--un-drop-shadow: ;--un-grayscale: ;--un-hue-rotate: ;--un-invert: ;--un-saturate: ;--un-sepia: ;--un-backdrop-blur: ;--un-backdrop-brightness: ;--un-backdrop-contrast: ;--un-backdrop-grayscale: ;--un-backdrop-hue-rotate: ;--un-backdrop-invert: ;--un-backdrop-opacity: ;--un-backdrop-saturate: ;--un-backdrop-sepia: ;}
-[type='text'], [type='email'], [type='url'], [type='password'], [type='number'], [type='date'], [type='datetime-local'], [type='month'], [type='search'], [type='tel'], [type='time'], [type='week'], [multiple], textarea, select { appearance: none;
-background-color: #fff;
-border-color: #6b7280;
-border-width: 1px;
-border-radius: 0;
-padding-top: 0.5rem;
-padding-right: 0.75rem;
-padding-bottom: 0.5rem;
-padding-left: 0.75rem;
-font-size: 1rem;
-line-height: 1.5rem;
---un-shadow: 0 0 #0000; }
-[type='text']:focus, [type='email']:focus, [type='url']:focus, [type='password']:focus, [type='number']:focus, [type='date']:focus, [type='datetime-local']:focus, [type='month']:focus, [type='search']:focus, [type='tel']:focus, [type='time']:focus, [type='week']:focus, [multiple]:focus, textarea:focus, select:focus { outline: 2px solid transparent;
-outline-offset: 2px;
---un-ring-inset: var(--un-empty,/*!*/ /*!*/);
---un-ring-offset-width: 0px;
---un-ring-offset-color: #fff;
---un-ring-color: #2563eb;
---un-ring-offset-shadow: var(--un-ring-inset) 0 0 0 var(--un-ring-offset-width) var(--un-ring-offset-color);
---un-ring-shadow: var(--un-ring-inset) 0 0 0 calc(1px + var(--un-ring-offset-width)) var(--un-ring-color);
-box-shadow: var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow);
-border-color: #2563eb; }
-input::placeholder, textarea::placeholder { color: #6b7280;
-opacity: 1; }
-::-webkit-datetime-edit-fields-wrapper { padding: 0; }
-::-webkit-date-and-time-value { min-height: 1.5em; }
-::-webkit-datetime-edit, ::-webkit-datetime-edit-year-field, ::-webkit-datetime-edit-month-field, ::-webkit-datetime-edit-day-field, ::-webkit-datetime-edit-hour-field, ::-webkit-datetime-edit-minute-field, ::-webkit-datetime-edit-second-field, ::-webkit-datetime-edit-millisecond-field, ::-webkit-datetime-edit-meridiem-field { padding-top: 0;
-padding-bottom: 0; }
-select { background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='none' viewBox='0 0 20 20'%3e%3cpath stroke='%236b7280' stroke-linecap='round' stroke-linejoin='round' stroke-width='1.5' d='M6 8l4 4 4-4'/%3e%3c/svg%3e");
-background-position: right 0.5rem center;
-background-repeat: no-repeat;
-background-size: 1.5em 1.5em;
-padding-right: 2.5rem;
-print-color-adjust: exact; }
-[multiple] { background-image: initial;
-background-position: initial;
-background-repeat: unset;
-background-size: initial;
-padding-right: 0.75rem;
-print-color-adjust: unset; }
-[type='checkbox'], [type='radio'] { appearance: none;
-padding: 0;
-print-color-adjust: exact;
-display: inline-block;
-vertical-align: middle;
-background-origin: border-box;
-user-select: none;
-flex-shrink: 0;
-height: 1rem;
-width: 1rem;
-color: #2563eb;
-background-color: #fff;
-border-color: #6b7280;
-border-width: 1px;
---un-shadow: 0 0 #0000; }
-[type='checkbox'] { border-radius: 0; }
-[type='radio'] { border-radius: 100%; }
-[type='checkbox']:focus, [type='radio']:focus { outline: 2px solid transparent;
-outline-offset: 2px;
---un-ring-inset: var(--un-empty,/*!*/ /*!*/);
---un-ring-offset-width: 2px;
---un-ring-offset-color: #fff;
---un-ring-color: #2563eb;
---un-ring-offset-shadow: var(--un-ring-inset) 0 0 0 var(--un-ring-offset-width) var(--un-ring-offset-color);
---un-ring-shadow: var(--un-ring-inset) 0 0 0 calc(2px + var(--un-ring-offset-width)) var(--un-ring-color);
-box-shadow: var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow); }
-[type='checkbox']:checked, [type='radio']:checked { border-color: transparent;
-background-color: currentColor;
-background-size: 100% 100%;
-background-position: center;
-background-repeat: no-repeat; }
-[type='checkbox']:checked { background-image: url("data:image/svg+xml,%3csvg viewBox='0 0 16 16' fill='white' xmlns='http://www.w3.org/2000/svg'%3e%3cpath d='M12.207 4.793a1 1 0 010 1.414l-5 5a1 1 0 01-1.414 0l-2-2a1 1 0 011.414-1.414L6.5 9.086l4.293-4.293a1 1 0 011.414 0z'/%3e%3c/svg%3e"); }
-[type='radio']:checked { background-image: url("data:image/svg+xml,%3csvg viewBox='0 0 16 16' fill='white' xmlns='http://www.w3.org/2000/svg'%3e%3ccircle cx='8' cy='8' r='3'/%3e%3c/svg%3e"); }
-[type='checkbox']:checked:hover, [type='checkbox']:checked:focus, [type='radio']:checked:hover, [type='radio']:checked:focus { border-color: transparent;
-background-color: currentColor; }
-[type='checkbox']:indeterminate { background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='none' viewBox='0 0 16 16'%3e%3cpath stroke='white' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M4 8h8'/%3e%3c/svg%3e");
-border-color: transparent;
-background-color: currentColor;
-background-size: 100% 100%;
-background-position: center;
-background-repeat: no-repeat; }
-[type='checkbox']:indeterminate:hover, [type='checkbox']:indeterminate:focus { border-color: transparent;
-background-color: currentColor; }
-[type='file'] { background: unset;
-border-color: inherit;
-border-width: 0;
-border-radius: 0;
-padding: 0;
-font-size: unset;
-line-height: inherit; }
-[type='file']:focus { outline: 1px solid ButtonText , 1px auto -webkit-focus-ring-color; }
-/* layer: default */
-.visible{visibility:visible;}
-.relative{position:relative;}
-.mt-10{margin-top:2.5rem;}
-.mt-2{margin-top:0.5rem;}
-.block{display:block;}
-.contents{display:contents;}
-.list-item{display:list-item;}
-.hidden{display:none;}
-.h6{height:1.5rem;}
-.min-h-screen{min-height:100vh;}
-.w-full{width:100%;}
-.flex{display:flex;}
-.flex-col{flex-direction:column;}
-.table{display:table;}
-.border-collapse{border-collapse:collapse;}
-.transform{transform:translateX(var(--un-translate-x)) translateY(var(--un-translate-y)) translateZ(var(--un-translate-z)) rotate(var(--un-rotate)) rotateX(var(--un-rotate-x)) rotateY(var(--un-rotate-y)) rotateZ(var(--un-rotate-z)) skewX(var(--un-skew-x)) skewY(var(--un-skew-y)) scaleX(var(--un-scale-x)) scaleY(var(--un-scale-y)) scaleZ(var(--un-scale-z));}
-.resize{resize:both;}
-.items-center{align-items:center;}
-.justify-center{justify-content:center;}
-.justify-between{justify-content:space-between;}
-.space-y-6>:not([hidden])~:not([hidden]){--un-space-y-reverse:0;margin-top:calc(1.5rem * calc(1 - var(--un-space-y-reverse)));margin-bottom:calc(1.5rem * var(--un-space-y-reverse));}
-.border{border-width:1px;}
-.border-0{border-width:0;}
-.rounded-md{border-radius:0.375rem;}
-.\!bg-indigo-600{--un-bg-opacity:1 !important;background-color:rgba(79,70,229,var(--un-bg-opacity)) !important;}
-.hover\:\!bg-indigo-500:hover{--un-bg-opacity:1 !important;background-color:rgba(99,102,241,var(--un-bg-opacity)) !important;}
-.px-3{padding-left:0.75rem;padding-right:0.75rem;}
-.px-6{padding-left:1.5rem;padding-right:1.5rem;}
-.py-1\.5{padding-top:0.375rem;padding-bottom:0.375rem;}
-.py-12{padding-top:3rem;padding-bottom:3rem;}
-.text-sm{font-size:0.875rem;line-height:1.25rem;}
-.font-medium{font-weight:500;}
-.font-semibold{font-weight:600;}
-.leading-6{line-height:1.5rem;}
-.text-gray-900{--un-text-opacity:1;color:rgba(17,24,39,var(--un-text-opacity));}
-.text-white{--un-text-opacity:1;color:rgba(255,255,255,var(--un-text-opacity));}
-.placeholder\:text-gray-400::placeholder{--un-text-opacity:1;color:rgba(156,163,175,var(--un-text-opacity));}
-.underline{text-decoration-line:underline;}
-.tab{-moz-tab-size:4;-o-tab-size:4;tab-size:4;}
-.shadow-sm{--un-shadow:var(--un-shadow-inset) 0 1px 2px 0 var(--un-shadow-color, rgba(0,0,0,0.05));box-shadow:var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow);}
-.focus-visible\:outline-2:focus-visible{outline-width:2px;}
-.focus-visible\:outline-indigo-600:focus-visible{--un-outline-color-opacity:1;outline-color:rgba(79,70,229,var(--un-outline-color-opacity));}
-.focus-visible\:outline-offset-2:focus-visible{outline-offset:2px;}
-.outline{outline-style:solid;}
-.focus-visible\:outline:focus-visible{outline-style:solid;}
-.ring-1{--un-ring-width:1px;--un-ring-offset-shadow:var(--un-ring-inset) 0 0 0 var(--un-ring-offset-width) var(--un-ring-offset-color);--un-ring-shadow:var(--un-ring-inset) 0 0 0 calc(var(--un-ring-width) + var(--un-ring-offset-width)) var(--un-ring-color);box-shadow:var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow);}
-.focus\:ring-2:focus{--un-ring-width:2px;--un-ring-offset-shadow:var(--un-ring-inset) 0 0 0 var(--un-ring-offset-width) var(--un-ring-offset-color);--un-ring-shadow:var(--un-ring-inset) 0 0 0 calc(var(--un-ring-width) + var(--un-ring-offset-width)) var(--un-ring-color);box-shadow:var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow);}
-.ring-gray-300{--un-ring-opacity:1;--un-ring-color:rgba(209,213,219,var(--un-ring-opacity));}
-.focus\:ring-indigo-600:focus{--un-ring-opacity:1;--un-ring-color:rgba(79,70,229,var(--un-ring-opacity));}
-.ring-inset{--un-ring-inset:inset;}
-.focus\:ring-inset:focus{--un-ring-inset:inset;}
-@media (min-width: 640px){
-.sm\:mx-auto{margin-left:auto;margin-right:auto;}
-.sm\:max-w-sm{max-width:24rem;}
-.sm\:w-full{width:100%;}
-.sm\:text-sm{font-size:0.875rem;line-height:1.25rem;}
-.sm\:leading-6{line-height:1.5rem;}
-}
-@media (min-width: 1024px){
-.lg\:px-8{padding-left:2rem;padding-right:2rem;}
-}
\ No newline at end of file
diff --git a/pages/vite-env.d.ts b/pages/vite-env.d.ts
new file mode 100644
index 00000000..11f02fe2
--- /dev/null
+++ b/pages/vite-env.d.ts
@@ -0,0 +1 @@
+/// <reference types="vite/client" />
diff --git a/pages/vite.config.ts b/pages/vite.config.ts
new file mode 100644
index 00000000..dd23d757
--- /dev/null
+++ b/pages/vite.config.ts
@@ -0,0 +1,35 @@
+import { defineConfig } from "vite";
+import UnoCSS from "unocss/vite";
+import vue from "@vitejs/plugin-vue";
+import pkg from "../package.json";
+
+export default defineConfig({
+	base: "/",
+	build: {
+		outDir: "./dist",
+	},
+	// main.ts is in pages/ directory
+	resolve: {
+		alias: {
+			vue: "vue/dist/vue.esm-bundler",
+		},
+	},
+	server: {
+		hmr: {
+			clientPort: 5173,
+		},
+	},
+	define: {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+		__VERSION__: JSON.stringify(pkg.version),
+	},
+	ssr: {
+		noExternal: ["@prisma/client"],
+	},
+	plugins: [
+		UnoCSS({
+			mode: "global",
+		}),
+		vue(),
+	],
+});
diff --git a/prisma.ts b/prisma.ts
index 82d8c1d5..63566b3d 100644
--- a/prisma.ts
+++ b/prisma.ts
@@ -1,17 +1,11 @@
+import { ConfigManager } from "config-manager";
+
 // Proxies all `bunx prisma` commands with an environment variable
+const config = await new ConfigManager({}).getConfig();
 
-import { getConfig } from "@config";
+process.stdout.write(
+	`postgresql://${config.database.username}:${config.database.password}@${config.database.host}:${config.database.port}/${config.database.database}\n`
+);
 
-const args = process.argv.slice(2);
-const config = getConfig();
-
-const { stdout } = Bun.spawn(["bunx", "prisma", ...args], {
-	env: {
-		...process.env,
-		DATABASE_URL: `postgresql://${config.database.username}:${config.database.password}@${config.database.host}:${config.database.port}/${config.database.database}`,
-	},
-});
-
-// Show stdout
-const text = await new Response(stdout).text();
-console.log(text);
+// Ends
+process.exit(0);
diff --git a/prisma/migrations/20231202001242_add_source/migration.sql b/prisma/migrations/20231202001242_add_source/migration.sql
new file mode 100644
index 00000000..272e2eb2
--- /dev/null
+++ b/prisma/migrations/20231202001242_add_source/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Status" ADD COLUMN     "contentSource" TEXT NOT NULL DEFAULT '';
diff --git a/prisma/migrations/20231206215508_add_openid/migration.sql b/prisma/migrations/20231206215508_add_openid/migration.sql
new file mode 100644
index 00000000..32b92f4d
--- /dev/null
+++ b/prisma/migrations/20231206215508_add_openid/migration.sql
@@ -0,0 +1,20 @@
+-- CreateTable
+CREATE TABLE "OpenIdLoginFlow" (
+    "id" UUID NOT NULL DEFAULT uuid_generate_v7(),
+    "codeVerifier" TEXT NOT NULL,
+
+    CONSTRAINT "OpenIdLoginFlow_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "OpenIdAccount" (
+    "id" UUID NOT NULL DEFAULT uuid_generate_v7(),
+    "userId" UUID,
+    "serverId" TEXT NOT NULL,
+    "issuerId" TEXT NOT NULL,
+
+    CONSTRAINT "OpenIdAccount_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "OpenIdAccount" ADD CONSTRAINT "OpenIdAccount_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;
diff --git a/prisma/migrations/20231206231959_add_issuer_and_client_to_flows/migration.sql b/prisma/migrations/20231206231959_add_issuer_and_client_to_flows/migration.sql
new file mode 100644
index 00000000..4e0ca8ae
--- /dev/null
+++ b/prisma/migrations/20231206231959_add_issuer_and_client_to_flows/migration.sql
@@ -0,0 +1,12 @@
+/*
+  Warnings:
+
+  - Added the required column `issuerId` to the `OpenIdLoginFlow` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- AlterTable
+ALTER TABLE "OpenIdLoginFlow" ADD COLUMN     "applicationId" UUID,
+ADD COLUMN     "issuerId" TEXT NOT NULL;
+
+-- AddForeignKey
+ALTER TABLE "OpenIdLoginFlow" ADD CONSTRAINT "OpenIdLoginFlow_applicationId_fkey" FOREIGN KEY ("applicationId") REFERENCES "Application"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/prisma/migrations/20231206232131_make_client_id_unique/migration.sql b/prisma/migrations/20231206232131_make_client_id_unique/migration.sql
new file mode 100644
index 00000000..99632ccb
--- /dev/null
+++ b/prisma/migrations/20231206232131_make_client_id_unique/migration.sql
@@ -0,0 +1,8 @@
+/*
+  Warnings:
+
+  - A unique constraint covering the columns `[client_id]` on the table `Application` will be added. If there are existing duplicate values, this will fail.
+
+*/
+-- CreateIndex
+CREATE UNIQUE INDEX "Application_client_id_key" ON "Application"("client_id");
diff --git a/prisma/migrations/20240304012450_add_moderation_data/migration.sql b/prisma/migrations/20240304012450_add_moderation_data/migration.sql
new file mode 100644
index 00000000..8b7a8fc1
--- /dev/null
+++ b/prisma/migrations/20240304012450_add_moderation_data/migration.sql
@@ -0,0 +1,40 @@
+-- AlterTable
+ALTER TABLE "Instance" ADD COLUMN     "disableAutomoderation" BOOLEAN NOT NULL DEFAULT false;
+
+-- AlterTable
+ALTER TABLE "User" ADD COLUMN     "disableAutomoderation" BOOLEAN NOT NULL DEFAULT false;
+
+-- CreateTable
+CREATE TABLE "ModerationData" (
+    "id" UUID NOT NULL DEFAULT uuid_generate_v7(),
+    "statusId" UUID NOT NULL,
+    "creatorId" UUID NOT NULL,
+    "note" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "ModerationData_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "Flag" (
+    "id" UUID NOT NULL DEFAULT uuid_generate_v7(),
+    "statusId" UUID NOT NULL,
+    "userId" UUID NOT NULL,
+    "flagType" TEXT NOT NULL DEFAULT 'other',
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "Flag_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "ModerationData" ADD CONSTRAINT "ModerationData_statusId_fkey" FOREIGN KEY ("statusId") REFERENCES "Status"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ModerationData" ADD CONSTRAINT "ModerationData_creatorId_fkey" FOREIGN KEY ("creatorId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Flag" ADD CONSTRAINT "Flag_statusId_fkey" FOREIGN KEY ("statusId") REFERENCES "Status"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Flag" ADD CONSTRAINT "Flag_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/prisma/migrations/20240304042832_rework_moderation/migration.sql b/prisma/migrations/20240304042832_rework_moderation/migration.sql
new file mode 100644
index 00000000..460be492
--- /dev/null
+++ b/prisma/migrations/20240304042832_rework_moderation/migration.sql
@@ -0,0 +1,76 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `statusId` on the `Flag` table. All the data in the column will be lost.
+  - You are about to drop the column `userId` on the `Flag` table. All the data in the column will be lost.
+  - You are about to drop the `ModerationData` table. If the table is not empty, all the data it contains will be lost.
+
+*/
+-- DropForeignKey
+ALTER TABLE "Flag" DROP CONSTRAINT "Flag_statusId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "Flag" DROP CONSTRAINT "Flag_userId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "ModerationData" DROP CONSTRAINT "ModerationData_creatorId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "ModerationData" DROP CONSTRAINT "ModerationData_statusId_fkey";
+
+-- AlterTable
+ALTER TABLE "Flag" DROP COLUMN "statusId",
+DROP COLUMN "userId",
+ADD COLUMN     "flaggeStatusId" UUID,
+ADD COLUMN     "flaggedUserId" UUID;
+
+-- DropTable
+DROP TABLE "ModerationData";
+
+-- CreateTable
+CREATE TABLE "ModNote" (
+    "id" UUID NOT NULL DEFAULT uuid_generate_v7(),
+    "notedStatusId" UUID,
+    "notedUserId" UUID,
+    "modId" UUID NOT NULL,
+    "note" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "ModNote_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "ModTag" (
+    "id" UUID NOT NULL DEFAULT uuid_generate_v7(),
+    "taggedStatusId" UUID,
+    "taggedUserId" UUID,
+    "modId" UUID NOT NULL,
+    "tag" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "ModTag_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "ModNote" ADD CONSTRAINT "ModNote_notedStatusId_fkey" FOREIGN KEY ("notedStatusId") REFERENCES "Status"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ModNote" ADD CONSTRAINT "ModNote_notedUserId_fkey" FOREIGN KEY ("notedUserId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ModNote" ADD CONSTRAINT "ModNote_modId_fkey" FOREIGN KEY ("modId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ModTag" ADD CONSTRAINT "ModTag_taggedStatusId_fkey" FOREIGN KEY ("taggedStatusId") REFERENCES "Status"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ModTag" ADD CONSTRAINT "ModTag_taggedUserId_fkey" FOREIGN KEY ("taggedUserId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ModTag" ADD CONSTRAINT "ModTag_modId_fkey" FOREIGN KEY ("modId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Flag" ADD CONSTRAINT "Flag_flaggeStatusId_fkey" FOREIGN KEY ("flaggeStatusId") REFERENCES "Status"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Flag" ADD CONSTRAINT "Flag_flaggedUserId_fkey" FOREIGN KEY ("flaggedUserId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index 86874950..2e81d8a3 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -10,16 +10,17 @@ datasource db {
 }
 
 model Application {
-  id            String   @id @default(dbgenerated("uuid_generate_v7()")) @db.Uuid
-  name          String
-  website       String?
-  vapid_key     String?
-  client_id     String
-  secret        String
-  scopes        String
-  redirect_uris String
-  statuses      Status[] // One to many relation with Status
-  tokens        Token[] // One to many relation with Token
+  id               String            @id @default(dbgenerated("uuid_generate_v7()")) @db.Uuid
+  name             String
+  website          String?
+  vapid_key        String?
+  client_id        String            @unique
+  secret           String
+  scopes           String
+  redirect_uris    String
+  statuses         Status[] // One to many relation with Status
+  tokens           Token[] // One to many relation with Token
+  openIdLoginFlows OpenIdLoginFlow[]
 }
 
 model Emoji {
@@ -36,14 +37,15 @@ model Emoji {
 }
 
 model Instance {
-  id       String   @id @default(dbgenerated("uuid_generate_v7()")) @db.Uuid
-  base_url String
-  name     String
-  version  String
-  logo     Json
-  emojis   Emoji[] // One to many relation with Emoji
-  statuses Status[] // One to many relation with Status
-  users    User[] // One to many relation with User
+  id                    String   @id @default(dbgenerated("uuid_generate_v7()")) @db.Uuid
+  base_url              String
+  name                  String
+  version               String
+  logo                  Json
+  emojis                Emoji[] // One to many relation with Emoji
+  statuses              Status[] // One to many relation with Status
+  users                 User[] // One to many relation with User
+  disableAutomoderation Boolean  @default(false)
 }
 
 model Like {
@@ -103,6 +105,7 @@ model Status {
   isReblog             Boolean
   content              String         @default("")
   contentType          String         @default("text/plain")
+  contentSource        String         @default("")
   visibility           String
   inReplyToPost        Status?        @relation("StatusToStatusReply", fields: [inReplyToPostId], references: [id], onDelete: SetNull)
   inReplyToPostId      String?        @db.Uuid
@@ -123,6 +126,44 @@ model Status {
   pinnedBy             User[]         @relation("UserPinnedNotes")
   attachments          Attachment[]
   relatedNotifications Notification[]
+  flags                Flag[]
+  modNotes             ModNote[]
+  modTags              ModTag[]
+}
+
+model ModNote {
+  id            String   @id @default(dbgenerated("uuid_generate_v7()")) @db.Uuid
+  notedStatus   Status?  @relation(fields: [notedStatusId], references: [id], onDelete: Cascade)
+  notedStatusId String?  @db.Uuid
+  notedUser     User?    @relation("ModNoteToUser", fields: [notedUserId], references: [id], onDelete: Cascade)
+  notedUserId   String?  @db.Uuid
+  mod           User     @relation("ModNoteToMod", fields: [modId], references: [id], onDelete: Cascade)
+  modId         String   @db.Uuid
+  note          String
+  createdAt     DateTime @default(now())
+}
+
+model ModTag {
+  id             String   @id @default(dbgenerated("uuid_generate_v7()")) @db.Uuid
+  taggedStatus   Status?  @relation(fields: [taggedStatusId], references: [id], onDelete: Cascade)
+  taggedStatusId String?  @db.Uuid
+  taggedUser     User?    @relation("ModNoteToTaggedUser", fields: [taggedUserId], references: [id], onDelete: Cascade)
+  taggedUserId   String?  @db.Uuid
+  mod            User     @relation("ModTagToMod", fields: [modId], references: [id], onDelete: Cascade)
+  modId          String   @db.Uuid
+  tag            String
+  createdAt      DateTime @default(now())
+}
+
+// Used to tag notes and accounts with automatic moderation infractions
+model Flag {
+  id             String   @id @default(dbgenerated("uuid_generate_v7()")) @db.Uuid
+  flaggedStatus  Status?  @relation(fields: [flaggeStatusId], references: [id], onDelete: Cascade)
+  flaggeStatusId String?  @db.Uuid
+  flaggedUser    User?    @relation(fields: [flaggedUserId], references: [id], onDelete: Cascade)
+  flaggedUserId  String?  @db.Uuid
+  flagType       String   @default("other")
+  createdAt      DateTime @default(now())
 }
 
 model Token {
@@ -138,6 +179,14 @@ model Token {
   applicationId String?      @db.Uuid
 }
 
+model OpenIdLoginFlow {
+  id            String       @id @default(dbgenerated("uuid_generate_v7()")) @db.Uuid
+  codeVerifier  String
+  issuerId      String
+  application   Application? @relation(fields: [applicationId], references: [id], onDelete: Cascade)
+  applicationId String?      @db.Uuid
+}
+
 model Attachment {
   id            String  @id @default(dbgenerated("uuid_generate_v7()")) @db.Uuid
   url           String
@@ -169,36 +218,51 @@ model Notification {
 }
 
 model User {
-  id                   String         @id @default(dbgenerated("uuid_generate_v7()")) @db.Uuid
-  uri                  String         @unique
-  username             String         @unique
-  displayName          String
-  password             String? // Nullable
-  email                String?        @unique // Nullable
-  note                 String         @default("")
-  isAdmin              Boolean        @default(false)
-  endpoints            Json? // Nullable
-  source               Json
-  avatar               String
-  header               String
-  createdAt            DateTime       @default(now())
-  updatedAt            DateTime       @updatedAt
-  isBot                Boolean        @default(false)
-  isLocked             Boolean        @default(false)
-  isDiscoverable       Boolean        @default(false)
-  sanctions            String[]       @default([])
-  publicKey            String
-  privateKey           String? // Nullable
-  relationships        Relationship[] @relation("OwnerToRelationship") // One to many relation with Relationship
-  relationshipSubjects Relationship[] @relation("SubjectToRelationship") // One to many relation with Relationship
-  instance             Instance?      @relation(fields: [instanceId], references: [id], onDelete: Cascade) // Many to one relation with Instance
-  instanceId           String?        @db.Uuid
-  pinnedNotes          Status[]       @relation("UserPinnedNotes") // Many to many relation with Status
-  emojis               Emoji[] // Many to many relation with Emoji
-  statuses             Status[]       @relation("UserStatuses") // One to many relation with Status
-  tokens               Token[] // One to many relation with Token
-  likes                Like[]         @relation("UserLiked") // One to many relation with Like
-  statusesMentioned    Status[] // Many to many relation with Status
-  notifications        Notification[] // One to many relation with Notification
-  notified             Notification[] @relation("NotificationToNotified") // One to many relation with Notification
+  id                    String          @id @default(dbgenerated("uuid_generate_v7()")) @db.Uuid
+  uri                   String          @unique
+  username              String          @unique
+  displayName           String
+  password              String? // Nullable
+  email                 String?         @unique // Nullable
+  note                  String          @default("")
+  isAdmin               Boolean         @default(false)
+  endpoints             Json? // Nullable
+  source                Json
+  avatar                String
+  header                String
+  createdAt             DateTime        @default(now())
+  updatedAt             DateTime        @updatedAt
+  isBot                 Boolean         @default(false)
+  isLocked              Boolean         @default(false)
+  isDiscoverable        Boolean         @default(false)
+  sanctions             String[]        @default([])
+  publicKey             String
+  privateKey            String? // Nullable
+  relationships         Relationship[]  @relation("OwnerToRelationship") // One to many relation with Relationship
+  relationshipSubjects  Relationship[]  @relation("SubjectToRelationship") // One to many relation with Relationship
+  instance              Instance?       @relation(fields: [instanceId], references: [id], onDelete: Cascade) // Many to one relation with Instance
+  instanceId            String?         @db.Uuid
+  pinnedNotes           Status[]        @relation("UserPinnedNotes") // Many to many relation with Status
+  emojis                Emoji[] // Many to many relation with Emoji
+  statuses              Status[]        @relation("UserStatuses") // One to many relation with Status
+  tokens                Token[] // One to many relation with Token
+  likes                 Like[]          @relation("UserLiked") // One to many relation with Like
+  statusesMentioned     Status[] // Many to many relation with Status
+  notifications         Notification[] // One to many relation with Notification
+  notified              Notification[]  @relation("NotificationToNotified") // One to many relation with Notification
+  linkedOpenIdAccounts  OpenIdAccount[] // One to many relation with OpenIdAccount
+  flags                 Flag[]
+  modNotes              ModNote[]       @relation("ModNoteToUser")
+  modTags               ModTag[]        @relation("ModNoteToTaggedUser")
+  disableAutomoderation Boolean         @default(false)
+  createdModTags        ModTag[]        @relation("ModTagToMod")
+  createdModNotes       ModNote[]       @relation("ModNoteToMod")
+}
+
+model OpenIdAccount {
+  id       String  @id @default(dbgenerated("uuid_generate_v7()")) @db.Uuid
+  User     User?   @relation(fields: [userId], references: [id])
+  userId   String? @db.Uuid
+  serverId String // ID on the authorization server
+  issuerId String
 }
diff --git a/routes.ts b/routes.ts
new file mode 100644
index 00000000..b894201e
--- /dev/null
+++ b/routes.ts
@@ -0,0 +1,188 @@
+import type { RouteHandler } from "~server/api/routes.type";
+import type { APIRouteMeta } from "~types/api";
+
+const serverPath = process.cwd() + "/server/api";
+
+// Why are these routes specified manually instead of using Bun's FileSystemRouter?
+// This is to allow for compilation of the routes, so that we can minify them and
+// node_modules in production
+export const rawRoutes = {
+	"/api/v1/accounts": await import(serverPath + "/api/v1/accounts/index.ts"),
+	"/api/v1/accounts/familiar_followers": await import(
+		serverPath + "/api/v1/accounts/familiar_followers/index.ts"
+	),
+	"/api/v1/accounts/relationships": await import(
+		serverPath + "/api/v1/accounts/relationships/index.ts"
+	),
+	"/api/v1/accounts/search": await import(
+		serverPath + "/api/v1/accounts/search/index.ts"
+	),
+	"/api/v1/accounts/update_credentials": await import(
+		serverPath + "/api/v1/accounts/update_credentials/index.ts"
+	),
+	"/api/v1/accounts/verify_credentials": await import(
+		serverPath + "/api/v1/accounts/verify_credentials/index.ts"
+	),
+	"/api/v1/apps": await import(serverPath + "/api/v1/apps/index.ts"),
+	"/api/v1/apps/verify_credentials": await import(
+		serverPath + "/api/v1/apps/verify_credentials/index.ts"
+	),
+	"/api/v1/blocks": await import(serverPath + "/api/v1/blocks/index.ts"),
+	"/api/v1/custom_emojis": await import(
+		serverPath + "/api/v1/custom_emojis/index.ts"
+	),
+	"/api/v1/favourites": await import(
+		serverPath + "/api/v1/favourites/index.ts"
+	),
+	"/api/v1/follow_requests": await import(
+		serverPath + "/api/v1/follow_requests/index.ts"
+	),
+	"/api/v1/instance": await import(serverPath + "/api/v1/instance/index.ts"),
+	"/api/v1/media": await import(serverPath + "/api/v1/media/index.ts"),
+	"/api/v1/mutes": await import(serverPath + "/api/v1/mutes/index.ts"),
+	"/api/v1/notifications": await import(
+		serverPath + "/api/v1/notifications/index.ts"
+	),
+	"/api/v1/profile/avatar": await import(
+		serverPath + "/api/v1/profile/avatar.ts"
+	),
+	"/api/v1/profile/header": await import(
+		serverPath + "/api/v1/profile/header.ts"
+	),
+	"/api/v1/statuses": await import(serverPath + "/api/v1/statuses/index.ts"),
+	"/api/v1/timelines/home": await import(
+		serverPath + "/api/v1/timelines/home.ts"
+	),
+	"/api/v1/timelines/public": await import(
+		serverPath + "/api/v1/timelines/public.ts"
+	),
+	"/api/v2/media": await import(serverPath + "/api/v2/media/index.ts"),
+	"/api/v2/search": await import(serverPath + "/api/v2/search/index.ts"),
+	"/auth/login": await import(serverPath + "/auth/login/index.ts"),
+	"/nodeinfo/2.0": await import(serverPath + "/nodeinfo/2.0/index.ts"),
+	"/oauth/authorize-external": await import(
+		serverPath + "/oauth/authorize-external/index.ts"
+	),
+	"/oauth/providers": await import(serverPath + "/oauth/providers/index.ts"),
+	"/oauth/token": await import(serverPath + "/oauth/token/index.ts"),
+	"/api/v1/accounts/[id]": await import(
+		serverPath + "/api/v1/accounts/[id]/index.ts"
+	),
+	"/api/v1/accounts/[id]/block": await import(
+		serverPath + "/api/v1/accounts/[id]/block.ts"
+	),
+	"/api/v1/accounts/[id]/follow": await import(
+		serverPath + "/api/v1/accounts/[id]/follow.ts"
+	),
+	"/api/v1/accounts/[id]/followers": await import(
+		serverPath + "/api/v1/accounts/[id]/followers.ts"
+	),
+	"/api/v1/accounts/[id]/following": await import(
+		serverPath + "/api/v1/accounts/[id]/following.ts"
+	),
+	"/api/v1/accounts/[id]/mute": await import(
+		serverPath + "/api/v1/accounts/[id]/mute.ts"
+	),
+	"/api/v1/accounts/[id]/note": await import(
+		serverPath + "/api/v1/accounts/[id]/note.ts"
+	),
+	"/api/v1/accounts/[id]/pin": await import(
+		serverPath + "/api/v1/accounts/[id]/pin.ts"
+	),
+	"/api/v1/accounts/[id]/remove_from_followers": await import(
+		serverPath + "/api/v1/accounts/[id]/remove_from_followers.ts"
+	),
+	"/api/v1/accounts/[id]/statuses": await import(
+		serverPath + "/api/v1/accounts/[id]/statuses.ts"
+	),
+	"/api/v1/accounts/[id]/unblock": await import(
+		serverPath + "/api/v1/accounts/[id]/unblock.ts"
+	),
+	"/api/v1/accounts/[id]/unfollow": await import(
+		serverPath + "/api/v1/accounts/[id]/unfollow.ts"
+	),
+	"/api/v1/accounts/[id]/unmute": await import(
+		serverPath + "/api/v1/accounts/[id]/unmute.ts"
+	),
+	"/api/v1/accounts/[id]/unpin": await import(
+		serverPath + "/api/v1/accounts/[id]/unpin.ts"
+	),
+	"/api/v1/follow_requests/[account_id]/authorize": await import(
+		serverPath + "/api/v1/follow_requests/[account_id]/authorize.ts"
+	),
+	"/api/v1/follow_requests/[account_id]/reject": await import(
+		serverPath + "/api/v1/follow_requests/[account_id]/reject.ts"
+	),
+	"/api/v1/media/[id]": await import(
+		serverPath + "/api/v1/media/[id]/index.ts"
+	),
+	"/api/v1/statuses/[id]": await import(
+		serverPath + "/api/v1/statuses/[id]/index.ts"
+	),
+	"/api/v1/statuses/[id]/context": await import(
+		serverPath + "/api/v1/statuses/[id]/context.ts"
+	),
+	"/api/v1/statuses/[id]/favourite": await import(
+		serverPath + "/api/v1/statuses/[id]/favourite.ts"
+	),
+	"/api/v1/statuses/[id]/favourited_by": await import(
+		serverPath + "/api/v1/statuses/[id]/favourited_by.ts"
+	),
+	"/api/v1/statuses/[id]/pin": await import(
+		serverPath + "/api/v1/statuses/[id]/pin.ts"
+	),
+	"/api/v1/statuses/[id]/reblog": await import(
+		serverPath + "/api/v1/statuses/[id]/reblog.ts"
+	),
+	"/api/v1/statuses/[id]/reblogged_by": await import(
+		serverPath + "/api/v1/statuses/[id]/reblogged_by.ts"
+	),
+	"/api/v1/statuses/[id]/source": await import(
+		serverPath + "/api/v1/statuses/[id]/source.ts"
+	),
+	"/api/v1/statuses/[id]/unfavourite": await import(
+		serverPath + "/api/v1/statuses/[id]/unfavourite.ts"
+	),
+	"/api/v1/statuses/[id]/unpin": await import(
+		serverPath + "/api/v1/statuses/[id]/unpin.ts"
+	),
+	"/api/v1/statuses/[id]/unreblog": await import(
+		serverPath + "/api/v1/statuses/[id]/unreblog.ts"
+	),
+	"/media/[id]": await import(serverPath + "/media/[id]/index.ts"),
+	"/oauth/callback/[issuer]": await import(
+		serverPath + "/oauth/callback/[issuer]/index.ts"
+	),
+	"/object/[uuid]": await import(serverPath + "/object/[uuid]/index.ts"),
+	"/users/[uuid]": await import(serverPath + "/users/[uuid]/index.ts"),
+	"/users/[uuid]/inbox": await import(
+		serverPath + "/users/[uuid]/inbox/index.ts"
+	),
+	"/users/[uuid]/outbox": await import(
+		serverPath + "/users/[uuid]/outbox/index.ts"
+	),
+	"/[...404]": await import(serverPath + "/[...404].ts"),
+};
+
+// Returns the route filesystem path when given a URL
+export const routeMatcher = new Bun.FileSystemRouter({
+	style: "nextjs",
+	dir: process.cwd() + "/server/api",
+});
+
+export const matchRoute = <T = Record<string, never>>(url: string) => {
+	const route = routeMatcher.match(url);
+	if (!route) return { file: null, matchedRoute: null };
+
+	return {
+		// @ts-expect-error TypeScript parses this as a defined object instead of an arbitrarily editable route file
+		file: rawRoutes[route.name] as Promise<
+			| {
+					meta: APIRouteMeta;
+					default: RouteHandler<T>;
+			  }
+			| undefined
+		>,
+		matchedRoute: route,
+	};
+};
diff --git a/server.ts b/server.ts
new file mode 100644
index 00000000..90ba79ef
--- /dev/null
+++ b/server.ts
@@ -0,0 +1,201 @@
+import { errorResponse, jsonResponse } from "@response";
+import { matches } from "ip-matching";
+import { getFromRequest } from "~database/entities/User";
+import type { ConfigManager, ConfigType } from "config-manager";
+import type { LogManager, MultiLogManager } from "log-manager";
+import { LogLevel } from "log-manager";
+import { RequestParser } from "request-parser";
+
+export const createServer = (
+	config: ConfigType,
+	configManager: ConfigManager,
+	logger: LogManager | MultiLogManager,
+	isProd: boolean
+) =>
+	Bun.serve({
+		port: config.http.bind_port,
+		hostname: config.http.bind || "0.0.0.0", // defaults to "0.0.0.0"
+		async fetch(req) {
+			// Check for banned IPs
+			const request_ip = this.requestIP(req)?.address ?? "";
+
+			for (const ip of config.http.banned_ips) {
+				try {
+					if (matches(ip, request_ip)) {
+						return new Response(undefined, {
+							status: 403,
+							statusText: "Forbidden",
+						});
+					}
+				} catch (e) {
+					console.error(`[-] Error while parsing banned IP "${ip}" `);
+					throw e;
+				}
+			}
+
+			// Check for banned user agents (regex)
+			const ua = req.headers.get("User-Agent") ?? "";
+
+			for (const agent of config.http.banned_user_agents) {
+				if (new RegExp(agent).test(ua)) {
+					return new Response(undefined, {
+						status: 403,
+						statusText: "Forbidden",
+					});
+				}
+			}
+
+			if (config.logging.log_requests) {
+				await logger.logRequest(
+					req,
+					config.logging.log_ip ? request_ip : undefined,
+					config.logging.log_requests_verbose
+				);
+			}
+
+			if (req.method === "OPTIONS") {
+				return jsonResponse({});
+			}
+
+			// If it isn't dynamically imported, it causes trouble with imports
+			// There shouldn't be a performance hit after bundling right?
+			const { matchRoute } = await import("~routes");
+
+			const { file: filePromise, matchedRoute } = matchRoute(req.url);
+
+			const file = await filePromise;
+
+			if (matchedRoute && file == undefined) {
+				await logger.log(
+					LogLevel.ERROR,
+					"Server",
+					`Route file ${matchedRoute.filePath} not found or not registered in the routes file`
+				);
+
+				return errorResponse("Route not found", 500);
+			}
+
+			if (
+				matchedRoute &&
+				matchedRoute.name !== "/[...404]" &&
+				file != undefined
+			) {
+				const meta = file.meta;
+
+				// Check for allowed requests
+				if (!meta.allowedMethods.includes(req.method as any)) {
+					return new Response(undefined, {
+						status: 405,
+						statusText: `Method not allowed: allowed methods are: ${meta.allowedMethods.join(
+							", "
+						)}`,
+					});
+				}
+
+				// TODO: Check for ratelimits
+				const auth = await getFromRequest(req);
+
+				// Check for authentication if required
+				if (meta.auth.required) {
+					if (!auth.user) {
+						return new Response(undefined, {
+							status: 401,
+							statusText: "Unauthorized",
+						});
+					}
+				} else if (
+					(meta.auth.requiredOnMethods ?? []).includes(
+						req.method as any
+					)
+				) {
+					if (!auth.user) {
+						return new Response(undefined, {
+							status: 401,
+							statusText: "Unauthorized",
+						});
+					}
+				}
+
+				let parsedRequest = {};
+
+				try {
+					parsedRequest = await new RequestParser(req).toObject();
+				} catch (e) {
+					await logger.logError(
+						LogLevel.ERROR,
+						"Server.RouteRequestParser",
+						e as Error
+					);
+					return new Response(undefined, {
+						status: 400,
+						statusText: "Bad request",
+					});
+				}
+
+				return await file.default(req.clone(), matchedRoute, {
+					auth,
+					configManager,
+					parsedRequest,
+				});
+			} else if (matchedRoute?.name === "/[...404]" || !matchedRoute) {
+				if (new URL(req.url).pathname.startsWith("/api")) {
+					return errorResponse("Route not found", 404);
+				}
+
+				// Proxy response from Vite at localhost:5173 if in development mode
+				if (isProd) {
+					if (new URL(req.url).pathname.startsWith("/assets")) {
+						const file = Bun.file(
+							`./pages/dist${new URL(req.url).pathname}`
+						);
+
+						// Serve from pages/dist/assets
+						if (await file.exists()) {
+							return new Response(file);
+						} else return errorResponse("Asset not found", 404);
+					}
+					if (new URL(req.url).pathname.startsWith("/api")) {
+						return errorResponse("Route not found", 404);
+					}
+
+					const file = Bun.file(`./pages/dist/index.html`);
+
+					// Serve from pages/dist
+					return new Response(file);
+				} else {
+					const proxy = await fetch(
+						req.url.replace(
+							config.http.base_url,
+							"http://localhost:5173"
+						)
+					).catch(async e => {
+						await logger.logError(
+							LogLevel.ERROR,
+							"Server.Proxy",
+							e as Error
+						);
+						await logger.log(
+							LogLevel.ERROR,
+							"Server.Proxy",
+							`The development Vite server is not running or the route is not found: ${req.url.replace(
+								config.http.base_url,
+								"http://localhost:5173"
+							)}`
+						);
+						return errorResponse("Route not found", 404);
+					});
+
+					if (
+						proxy.status !== 404 &&
+						!(await proxy.clone().text()).includes("404 Not Found")
+					) {
+						return proxy;
+					}
+
+					return errorResponse("Route not found", 404);
+				}
+			} else {
+				return errorResponse("Route not found", 404);
+			}
+		},
+	});
diff --git a/server/api/.well-known/host-meta/index.ts b/server/api/.well-known/host-meta/index.ts
index 2d746185..c473fe6d 100644
--- a/server/api/.well-known/host-meta/index.ts
+++ b/server/api/.well-known/host-meta/index.ts
@@ -1,7 +1,5 @@
-import { MatchedRoute } from "bun";
-import { getConfig, getHost } from "@config";
 import { xmlResponse } from "@response";
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 
 export const meta = applyConfig({
 	allowedMethods: ["GET"],
@@ -16,18 +14,13 @@ export const meta = applyConfig({
 });
 
 
-/**
- * Host meta endpoint
- */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
-	const config = getConfig();
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const config = await extraData.configManager.getConfig();
+	
 	return xmlResponse(`
-	<?xml version="1.0" encoding="UTF-8"?>
-	<XRD xmlns="http://docs.oasis-open.org/ns/xri/xrd-1.0">
+<?xml version="1.0" encoding="UTF-8"?>
+<XRD xmlns="http://docs.oasis-open.org/ns/xri/xrd-1.0">
 	<Link rel="lrdd" template="${config.http.base_url}/.well-known/webfinger?resource={uri}"/>
-	</XRD>
+</XRD>
 	`);
-};
+});
diff --git a/server/api/.well-known/lysand.ts b/server/api/.well-known/lysand.ts
index dd685ce0..5f7de0b6 100644
--- a/server/api/.well-known/lysand.ts
+++ b/server/api/.well-known/lysand.ts
@@ -1,7 +1,5 @@
 import { jsonResponse } from "@response";
-import { MatchedRoute } from "bun";
-import { getConfig } from "@config";
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 
 export const meta = applyConfig({
 	allowedMethods: ["GET"],
@@ -15,14 +13,9 @@ export const meta = applyConfig({
 	route: "/.well-known/lysand",
 });
 
-/**
- * Lysand instance metadata endpoint
- */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
-    const config = getConfig();
+export default apiRoute(async (req, matchedRoute, extraData) => {
+    const config = await extraData.configManager.getConfig();
+
 	// In the format acct:name@example.com
     return jsonResponse({
         type: "ServerMetadata",
@@ -47,4 +40,4 @@ export default async (
         website: "https://lysand.org",
         // TODO: Add admins, moderators field
     })
-};
+})
diff --git a/server/api/.well-known/nodeinfo/index.ts b/server/api/.well-known/nodeinfo/index.ts
index b8ae2fea..a348c4da 100644
--- a/server/api/.well-known/nodeinfo/index.ts
+++ b/server/api/.well-known/nodeinfo/index.ts
@@ -1,6 +1,4 @@
-import { MatchedRoute } from "bun";
-import { getConfig, getHost } from "@config";
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 
 export const meta = applyConfig({
 	allowedMethods: ["GET"],
@@ -15,14 +13,8 @@ export const meta = applyConfig({
 });
 
 
-/**
- * Redirect to /nodeinfo/2.0
- */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
-	const config = getConfig();
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const config = await extraData.configManager.getConfig();
 
 	return new Response("", {
 		status: 301,
@@ -30,4 +22,4 @@ export default async (
 			Location: `${config.http.base_url}/.well-known/nodeinfo/2.0`,
 		},
 	});
-};
+});
diff --git a/server/api/.well-known/webfinger/index.ts b/server/api/.well-known/webfinger/index.ts
index 15e28d1b..f9b35a84 100644
--- a/server/api/.well-known/webfinger/index.ts
+++ b/server/api/.well-known/webfinger/index.ts
@@ -1,7 +1,5 @@
 import { errorResponse, jsonResponse } from "@response";
-import { MatchedRoute } from "bun";
-import { getConfig, getHost } from "@config";
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -16,35 +14,30 @@ export const meta = applyConfig({
 	route: "/.well-known/webfinger",
 });
 
-/**
- * ActivityPub WebFinger endpoint
- */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	// In the format acct:name@example.com
 	const resource = matchedRoute.query.resource;
 	const requestedUser = resource.split("acct:")[1];
-
-	const config = getConfig();
-
+	
+	const config = await extraData.configManager.getConfig();
+	const host = new URL(config.http.base_url).hostname;
+	
 	// Check if user is a local user
-	if (requestedUser.split("@")[1] !== getHost()) {
+	if (requestedUser.split("@")[1] !== host) {
 		return errorResponse("User is a remote user", 404);
 	}
-
+	
 	const user = await client.user.findUnique({
 		where: { username: requestedUser.split("@")[0] },
 	});
-
+	
 	if (!user) {
 		return errorResponse("User not found", 404);
 	}
-
+	
 	return jsonResponse({
-		subject: `acct:${user.username}@${getHost()}`,
-
+		subject: `acct:${user.username}@${host}`,
+	
 		links: [
 			{
 				rel: "self",
@@ -63,4 +56,4 @@ export default async (
 			}
 		]
 	})
-};
+});
\ No newline at end of file
diff --git a/server/api/[...404].ts b/server/api/[...404].ts
new file mode 100644
index 00000000..871e3a3d
--- /dev/null
+++ b/server/api/[...404].ts
@@ -0,0 +1,21 @@
+import { apiRoute, applyConfig } from "@api";
+import { errorResponse } from "@response";
+
+export const meta = applyConfig({
+	allowedMethods: ["POST", "GET", "PUT", "PATCH", "DELETE"],
+	auth: {
+		required: false,
+	},
+	ratelimits: {
+		duration: 60,
+		max: 100,
+	},
+	route: "/[...404]",
+});
+
+/**
+ * Default catch-all route, returns a 404 error.
+ */
+export default apiRoute(() => {
+	return errorResponse("This API route does not exist", 404);
+});
diff --git a/server/api/api/v1/accounts/[id]/block.ts b/server/api/api/v1/accounts/[id]/block.ts
index e0e55252..d1fee876 100644
--- a/server/api/api/v1/accounts/[id]/block.ts
+++ b/server/api/api/v1/accounts/[id]/block.ts
@@ -1,14 +1,10 @@
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import {
 	createNewRelationship,
 	relationshipToAPI,
 } from "~database/entities/Relationship";
-import {
-	getFromRequest,
-	getRelationshipToOtherUser,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { getRelationshipToOtherUser } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -26,13 +22,10 @@ export const meta = applyConfig({
 /**
  * Blocks a user
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user: self } = await getFromRequest(req);
+	const { user: self } = extraData.auth;
 
 	if (!self) return errorResponse("Unauthorized", 401);
 
@@ -84,4 +77,4 @@ export default async (
 	});
 
 	return jsonResponse(relationshipToAPI(relationship));
-};
+});
diff --git a/server/api/api/v1/accounts/[id]/follow.ts b/server/api/api/v1/accounts/[id]/follow.ts
index 3d0b37d8..abd75e74 100644
--- a/server/api/api/v1/accounts/[id]/follow.ts
+++ b/server/api/api/v1/accounts/[id]/follow.ts
@@ -1,15 +1,10 @@
-import { parseRequest } from "@request";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import {
 	createNewRelationship,
 	relationshipToAPI,
 } from "~database/entities/Relationship";
-import {
-	getFromRequest,
-	getRelationshipToOtherUser,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { getRelationshipToOtherUser } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -27,21 +22,18 @@ export const meta = applyConfig({
 /**
  * Follow a user
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute<{
+	reblogs?: boolean;
+	notify?: boolean;
+	languages?: string[];
+}>(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user: self } = await getFromRequest(req);
+	const { user: self } = extraData.auth;
 
 	if (!self) return errorResponse("Unauthorized", 401);
 
-	const { languages, notify, reblogs } = await parseRequest<{
-		reblogs?: boolean;
-		notify?: boolean;
-		languages?: string[];
-	}>(req);
+	const { languages, notify, reblogs } = extraData.parsedRequest;
 
 	const user = await client.user.findUnique({
 		where: { id },
@@ -103,4 +95,4 @@ export default async (
 	});
 
 	return jsonResponse(relationshipToAPI(relationship));
-};
+});
diff --git a/server/api/api/v1/accounts/[id]/followers.ts b/server/api/api/v1/accounts/[id]/followers.ts
new file mode 100644
index 00000000..1de86d63
--- /dev/null
+++ b/server/api/api/v1/accounts/[id]/followers.ts
@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import { errorResponse, jsonResponse } from "@response";
+import { userRelations, userToAPI } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
+import { client } from "~database/datasource";
+
+export const meta = applyConfig({
+	allowedMethods: ["GET"],
+	ratelimits: {
+		max: 60,
+		duration: 60,
+	},
+	route: "/accounts/:id/followers",
+	auth: {
+		required: false,
+	},
+});
+
+/**
+ * Fetch all statuses for a user
+ */
+export default apiRoute<{
+	max_id?: string;
+	since_id?: string;
+	min_id?: string;
+	limit?: number;
+}>(async (req, matchedRoute, extraData) => {
+	const id = matchedRoute.params.id;
+
+	// TODO: Add pinned
+	const { max_id, min_id, since_id, limit = 20 } = extraData.parsedRequest;
+
+	const user = await client.user.findUnique({
+		where: { id },
+		include: userRelations,
+	});
+
+	if (limit < 1 || limit > 40) return errorResponse("Invalid limit", 400);
+
+	if (!user) return errorResponse("User not found", 404);
+
+	const objects = await client.user.findMany({
+		where: {
+			relationships: {
+				some: {
+					subjectId: user.id,
+					following: true,
+				},
+			},
+			id: {
+				lt: max_id,
+				gt: min_id,
+				gte: since_id,
+			},
+		},
+		include: userRelations,
+		take: Number(limit),
+		orderBy: {
+			id: "desc",
+		},
+	});
+
+	// Constuct HTTP Link header (next and prev)
+	const linkHeader = [];
+	if (objects.length > 0) {
+		const urlWithoutQuery = req.url.split("?")[0];
+		linkHeader.push(
+			`<${urlWithoutQuery}?max_id=${objects.at(-1)?.id}>; rel="next"`,
+			`<${urlWithoutQuery}?min_id=${objects[0].id}>; rel="prev"`
+		);
+	}
+
+	return jsonResponse(
+		await Promise.all(objects.map(object => userToAPI(object))),
+		200,
+		{
+			Link: linkHeader.join(", "),
+		}
+	);
+});
diff --git a/server/api/api/v1/accounts/[id]/following.ts b/server/api/api/v1/accounts/[id]/following.ts
new file mode 100644
index 00000000..a6c25988
--- /dev/null
+++ b/server/api/api/v1/accounts/[id]/following.ts
@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import { errorResponse, jsonResponse } from "@response";
+import { userRelations, userToAPI } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
+import { client } from "~database/datasource";
+
+export const meta = applyConfig({
+	allowedMethods: ["GET"],
+	ratelimits: {
+		max: 60,
+		duration: 60,
+	},
+	route: "/accounts/:id/following",
+	auth: {
+		required: false,
+	},
+});
+
+/**
+ * Fetch all statuses for a user
+ */
+export default apiRoute<{
+	max_id?: string;
+	since_id?: string;
+	min_id?: string;
+	limit?: number;
+}>(async (req, matchedRoute, extraData) => {
+	const id = matchedRoute.params.id;
+
+	// TODO: Add pinned
+	const { max_id, min_id, since_id, limit = 20 } = extraData.parsedRequest;
+
+	const user = await client.user.findUnique({
+		where: { id },
+		include: userRelations,
+	});
+
+	if (limit < 1 || limit > 40) return errorResponse("Invalid limit", 400);
+
+	if (!user) return errorResponse("User not found", 404);
+
+	const objects = await client.user.findMany({
+		where: {
+			relationshipSubjects: {
+				some: {
+					ownerId: user.id,
+					following: true,
+				},
+			},
+			id: {
+				lt: max_id,
+				gt: min_id,
+				gte: since_id,
+			},
+		},
+		include: userRelations,
+		take: Number(limit),
+		orderBy: {
+			id: "desc",
+		},
+	});
+
+	// Constuct HTTP Link header (next and prev)
+	const linkHeader = [];
+	if (objects.length > 0) {
+		const urlWithoutQuery = req.url.split("?")[0];
+		linkHeader.push(
+			`<${urlWithoutQuery}?max_id=${objects.at(-1)?.id}>; rel="next"`,
+			`<${urlWithoutQuery}?min_id=${objects[0].id}>; rel="prev"`
+		);
+	}
+
+	return jsonResponse(
+		await Promise.all(objects.map(object => userToAPI(object))),
+		200,
+		{
+			Link: linkHeader.join(", "),
+		}
+	);
+});
diff --git a/server/api/api/v1/accounts/[id]/index.ts b/server/api/api/v1/accounts/[id]/index.ts
index b1e609c4..b1527eb6 100644
--- a/server/api/api/v1/accounts/[id]/index.ts
+++ b/server/api/api/v1/accounts/[id]/index.ts
@@ -1,12 +1,7 @@
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import type { UserWithRelations } from "~database/entities/User";
-import {
-	getFromRequest,
-	userRelations,
-	userToAPI,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { userRelations, userToAPI } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -24,13 +19,14 @@ export const meta = applyConfig({
 /**
  * Fetch a user
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
+	// Check if ID is valid UUID
+	if (!id.match(/^[0-9a-fA-F]{24}$/)) {
+		return errorResponse("Invalid ID", 404);
+	}
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	let foundUser: UserWithRelations | null;
 	try {
@@ -45,4 +41,4 @@ export default async (
 	if (!foundUser) return errorResponse("User not found", 404);
 
 	return jsonResponse(userToAPI(foundUser, user?.id === foundUser.id));
-};
+});
diff --git a/server/api/api/v1/accounts/[id]/mute.ts b/server/api/api/v1/accounts/[id]/mute.ts
index 54dba828..e0790e8c 100644
--- a/server/api/api/v1/accounts/[id]/mute.ts
+++ b/server/api/api/v1/accounts/[id]/mute.ts
@@ -1,15 +1,10 @@
-import { parseRequest } from "@request";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import {
 	createNewRelationship,
 	relationshipToAPI,
 } from "~database/entities/Relationship";
-import {
-	getFromRequest,
-	getRelationshipToOtherUser,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { getRelationshipToOtherUser } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -27,21 +22,18 @@ export const meta = applyConfig({
 /**
  * Mute a user
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute<{
+	notifications: boolean;
+	duration: number;
+}>(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user: self } = await getFromRequest(req);
+	const { user: self } = extraData.auth;
 
 	if (!self) return errorResponse("Unauthorized", 401);
 
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	const { notifications, duration } = await parseRequest<{
-		notifications: boolean;
-		duration: number;
-	}>(req);
+	const { notifications, duration } = extraData.parsedRequest;
 
 	const user = await client.user.findUnique({
 		where: { id },
@@ -97,4 +89,4 @@ export default async (
 	// TODO: Implement duration
 
 	return jsonResponse(relationshipToAPI(relationship));
-};
+});
diff --git a/server/api/api/v1/accounts/[id]/note.ts b/server/api/api/v1/accounts/[id]/note.ts
index d67d6bda..b1dc07aa 100644
--- a/server/api/api/v1/accounts/[id]/note.ts
+++ b/server/api/api/v1/accounts/[id]/note.ts
@@ -1,15 +1,10 @@
-import { parseRequest } from "@request";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import {
 	createNewRelationship,
 	relationshipToAPI,
 } from "~database/entities/Relationship";
-import {
-	getFromRequest,
-	getRelationshipToOtherUser,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { getRelationshipToOtherUser } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -27,19 +22,16 @@ export const meta = applyConfig({
 /**
  * Sets a user note
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute<{
+	comment: string;
+}>(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user: self } = await getFromRequest(req);
+	const { user: self } = extraData.auth;
 
 	if (!self) return errorResponse("Unauthorized", 401);
 
-	const { comment } = await parseRequest<{
-		comment: string;
-	}>(req);
+	const { comment } = extraData.parsedRequest;
 
 	const user = await client.user.findUnique({
 		where: { id },
@@ -87,4 +79,4 @@ export default async (
 	});
 
 	return jsonResponse(relationshipToAPI(relationship));
-};
+});
diff --git a/server/api/api/v1/accounts/[id]/pin.ts b/server/api/api/v1/accounts/[id]/pin.ts
index 04cdb68e..4e3f398c 100644
--- a/server/api/api/v1/accounts/[id]/pin.ts
+++ b/server/api/api/v1/accounts/[id]/pin.ts
@@ -1,14 +1,10 @@
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import {
 	createNewRelationship,
 	relationshipToAPI,
 } from "~database/entities/Relationship";
-import {
-	getFromRequest,
-	getRelationshipToOtherUser,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { getRelationshipToOtherUser } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -26,13 +22,10 @@ export const meta = applyConfig({
 /**
  * Pin a user
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user: self } = await getFromRequest(req);
+	const { user: self } = extraData.auth;
 
 	if (!self) return errorResponse("Unauthorized", 401);
 
@@ -84,4 +77,4 @@ export default async (
 	});
 
 	return jsonResponse(relationshipToAPI(relationship));
-};
+});
diff --git a/server/api/api/v1/accounts/[id]/remove_from_followers.ts b/server/api/api/v1/accounts/[id]/remove_from_followers.ts
index 94e2ddb0..3a3495f3 100644
--- a/server/api/api/v1/accounts/[id]/remove_from_followers.ts
+++ b/server/api/api/v1/accounts/[id]/remove_from_followers.ts
@@ -1,14 +1,10 @@
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import {
 	createNewRelationship,
 	relationshipToAPI,
 } from "~database/entities/Relationship";
-import {
-	getFromRequest,
-	getRelationshipToOtherUser,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { getRelationshipToOtherUser } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -26,13 +22,10 @@ export const meta = applyConfig({
 /**
  * Removes an account from your followers list
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user: self } = await getFromRequest(req);
+	const { user: self } = extraData.auth;
 
 	if (!self) return errorResponse("Unauthorized", 401);
 
@@ -98,4 +91,4 @@ export default async (
 	}
 
 	return jsonResponse(relationshipToAPI(relationship));
-};
+});
diff --git a/server/api/api/v1/accounts/[id]/statuses.ts b/server/api/api/v1/accounts/[id]/statuses.ts
index 5ba37ec3..b4b5963b 100644
--- a/server/api/api/v1/accounts/[id]/statuses.ts
+++ b/server/api/api/v1/accounts/[id]/statuses.ts
@@ -1,9 +1,8 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import { statusAndUserRelations, statusToAPI } from "~database/entities/Status";
 import { userRelations } from "~database/entities/User";
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -21,10 +20,18 @@ export const meta = applyConfig({
 /**
  * Fetch all statuses for a user
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute<{
+	max_id?: string;
+	since_id?: string;
+	min_id?: string;
+	limit?: string;
+	only_media?: boolean;
+	exclude_replies?: boolean;
+	exclude_reblogs?: boolean;
+	// TODO: Add with_muted
+	pinned?: boolean;
+	tagged?: string;
+}>(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
 	// TODO: Add pinned
@@ -35,18 +42,7 @@ export default async (
 		limit = "20",
 		exclude_reblogs,
 		pinned,
-	}: {
-		max_id?: string;
-		since_id?: string;
-		min_id?: string;
-		limit?: string;
-		only_media?: boolean;
-		exclude_replies?: boolean;
-		exclude_reblogs?: boolean;
-		// TODO: Add with_muted
-		pinned?: boolean;
-		tagged?: string;
-	} = matchedRoute.query;
+	} = extraData.parsedRequest;
 
 	const user = await client.user.findUnique({
 		where: { id },
@@ -131,4 +127,4 @@ export default async (
 			Link: linkHeader.join(", "),
 		}
 	);
-};
+});
diff --git a/server/api/api/v1/accounts/[id]/unblock.ts b/server/api/api/v1/accounts/[id]/unblock.ts
index ea0139c2..ebfdeeb5 100644
--- a/server/api/api/v1/accounts/[id]/unblock.ts
+++ b/server/api/api/v1/accounts/[id]/unblock.ts
@@ -1,14 +1,10 @@
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import {
 	createNewRelationship,
 	relationshipToAPI,
 } from "~database/entities/Relationship";
-import {
-	getFromRequest,
-	getRelationshipToOtherUser,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { getRelationshipToOtherUser } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -26,13 +22,10 @@ export const meta = applyConfig({
 /**
  * Blocks a user
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user: self } = await getFromRequest(req);
+	const { user: self } = extraData.auth;
 
 	if (!self) return errorResponse("Unauthorized", 401);
 
@@ -84,4 +77,4 @@ export default async (
 	});
 
 	return jsonResponse(relationshipToAPI(relationship));
-};
+});
diff --git a/server/api/api/v1/accounts/[id]/unfollow.ts b/server/api/api/v1/accounts/[id]/unfollow.ts
index de6ba90a..56fc0f8d 100644
--- a/server/api/api/v1/accounts/[id]/unfollow.ts
+++ b/server/api/api/v1/accounts/[id]/unfollow.ts
@@ -1,14 +1,10 @@
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import {
 	createNewRelationship,
 	relationshipToAPI,
 } from "~database/entities/Relationship";
-import {
-	getFromRequest,
-	getRelationshipToOtherUser,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { getRelationshipToOtherUser } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -26,13 +22,10 @@ export const meta = applyConfig({
 /**
  * Unfollows a user
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user: self } = await getFromRequest(req);
+	const { user: self } = extraData.auth;
 
 	if (!self) return errorResponse("Unauthorized", 401);
 
@@ -84,4 +77,4 @@ export default async (
 	});
 
 	return jsonResponse(relationshipToAPI(relationship));
-};
+});
diff --git a/server/api/api/v1/accounts/[id]/unmute.ts b/server/api/api/v1/accounts/[id]/unmute.ts
index 5a498a24..b5c64fde 100644
--- a/server/api/api/v1/accounts/[id]/unmute.ts
+++ b/server/api/api/v1/accounts/[id]/unmute.ts
@@ -1,14 +1,10 @@
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import {
 	createNewRelationship,
 	relationshipToAPI,
 } from "~database/entities/Relationship";
-import {
-	getFromRequest,
-	getRelationshipToOtherUser,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { getRelationshipToOtherUser } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -26,13 +22,10 @@ export const meta = applyConfig({
 /**
  * Unmute a user
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user: self } = await getFromRequest(req);
+	const { user: self } = extraData.auth;
 
 	if (!self) return errorResponse("Unauthorized", 401);
 
@@ -86,4 +79,4 @@ export default async (
 	});
 
 	return jsonResponse(relationshipToAPI(relationship));
-};
+});
diff --git a/server/api/api/v1/accounts/[id]/unpin.ts b/server/api/api/v1/accounts/[id]/unpin.ts
index ee52384e..1e1ea84d 100644
--- a/server/api/api/v1/accounts/[id]/unpin.ts
+++ b/server/api/api/v1/accounts/[id]/unpin.ts
@@ -1,14 +1,10 @@
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import {
 	createNewRelationship,
 	relationshipToAPI,
 } from "~database/entities/Relationship";
-import {
-	getFromRequest,
-	getRelationshipToOtherUser,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { getRelationshipToOtherUser } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -26,13 +22,10 @@ export const meta = applyConfig({
 /**
  * Unpin a user
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user: self } = await getFromRequest(req);
+	const { user: self } = extraData.auth;
 
 	if (!self) return errorResponse("Unauthorized", 401);
 
@@ -84,4 +77,4 @@ export default async (
 	});
 
 	return jsonResponse(relationshipToAPI(relationship));
-};
+});
diff --git a/server/api/api/v1/accounts/familiar_followers/index.ts b/server/api/api/v1/accounts/familiar_followers/index.ts
index f3667b00..bf697de0 100644
--- a/server/api/api/v1/accounts/familiar_followers/index.ts
+++ b/server/api/api/v1/accounts/familiar_followers/index.ts
@@ -1,11 +1,6 @@
-import { parseRequest } from "@request";
 import { errorResponse, jsonResponse } from "@response";
-import {
-	getFromRequest,
-	userRelations,
-	userToAPI,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { userRelations, userToAPI } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -23,14 +18,14 @@ export const meta = applyConfig({
 /**
  * Find familiar followers (followers of a user that you also follow)
  */
-export default async (req: Request): Promise<Response> => {
-	const { user: self } = await getFromRequest(req);
+export default apiRoute<{
+	id: string[];
+}>(async (req, matchedRoute, extraData) => {
+	const { user: self } = extraData.auth;
 
 	if (!self) return errorResponse("Unauthorized", 401);
 
-	const { "id[]": ids } = await parseRequest<{
-		"id[]": string[];
-	}>(req);
+	const { id: ids } = extraData.parsedRequest;
 
 	// Minimum id count 1, maximum 10
 	if (!ids || ids.length < 1 || ids.length > 10) {
@@ -67,4 +62,4 @@ export default async (req: Request): Promise<Response> => {
 	});
 
 	return jsonResponse(output.map(o => userToAPI(o)));
-};
+});
diff --git a/server/api/api/v1/accounts/index.ts b/server/api/api/v1/accounts/index.ts
index 678384db..9a6e8925 100644
--- a/server/api/api/v1/accounts/index.ts
+++ b/server/api/api/v1/accounts/index.ts
@@ -1,8 +1,6 @@
-import { getConfig } from "@config";
-import { parseRequest } from "@request";
 import { jsonResponse } from "@response";
 import { tempmailDomains } from "@tempmail";
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 import { createNewLocalUser } from "~database/entities/User";
 import ISO6391 from "iso-639-1";
@@ -15,26 +13,32 @@ export const meta = applyConfig({
 		duration: 60,
 	},
 	auth: {
-		required: true,
+		required: false,
 	},
 });
 
-/**
- * Creates a new user
- */
-export default async (req: Request): Promise<Response> => {
+export default apiRoute<{
+	username: string;
+	email: string;
+	password: string;
+	agreement: boolean;
+	locale: string;
+	reason: string;
+}>(async (req, matchedRoute, extraData) => {
 	// TODO: Add Authorization check
 
-	const body = await parseRequest<{
-		username: string;
-		email: string;
-		password: string;
-		agreement: boolean;
-		locale: string;
-		reason: string;
-	}>(req);
+	const body = extraData.parsedRequest;
 
-	const config = getConfig();
+	const config = await extraData.configManager.getConfig();
+
+	if (!config.signups.registration) {
+		return jsonResponse(
+			{
+				error: "Registration is disabled",
+			},
+			422
+		);
+	}
 
 	const errors: {
 		details: Record<
@@ -85,8 +89,8 @@ export default async (req: Request): Promise<Response> => {
 
 	// Check if username doesnt match filters
 	if (
-		config.filters.username_filters.some(
-			filter => body.username?.match(filter)
+		config.filters.username_filters.some(filter =>
+			body.username?.match(filter)
 		)
 	) {
 		errors.details.username.push({
@@ -176,10 +180,13 @@ export default async (req: Request): Promise<Response> => {
 						.join(", ")}`
 			)
 			.join(", ");
-		return jsonResponse({
-			error: `Validation failed: ${errorsText}`,
-			details: errors.details,
-		});
+		return jsonResponse(
+			{
+				error: `Validation failed: ${errorsText}`,
+				details: errors.details,
+			},
+			422
+		);
 	}
 
 	await createNewLocalUser({
@@ -191,4 +198,4 @@ export default async (req: Request): Promise<Response> => {
 	return new Response("", {
 		status: 200,
 	});
-};
+});
diff --git a/server/api/api/v1/accounts/relationships/index.ts b/server/api/api/v1/accounts/relationships/index.ts
index 89b32f0e..bed66e35 100644
--- a/server/api/api/v1/accounts/relationships/index.ts
+++ b/server/api/api/v1/accounts/relationships/index.ts
@@ -1,11 +1,9 @@
-import { parseRequest } from "@request";
 import { errorResponse, jsonResponse } from "@response";
 import {
 	createNewRelationship,
 	relationshipToAPI,
 } from "~database/entities/Relationship";
-import { getFromRequest } from "~database/entities/User";
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -23,14 +21,14 @@ export const meta = applyConfig({
 /**
  * Find relationships
  */
-export default async (req: Request): Promise<Response> => {
-	const { user: self } = await getFromRequest(req);
+export default apiRoute<{
+	id: string[];
+}>(async (req, matchedRoute, extraData) => {
+	const { user: self } = extraData.auth;
 
 	if (!self) return errorResponse("Unauthorized", 401);
 
-	const { "id[]": ids } = await parseRequest<{
-		"id[]": string[];
-	}>(req);
+	const { id: ids } = extraData.parsedRequest;
 
 	// Minimum id count 1, maximum 10
 	if (!ids || ids.length < 1 || ids.length > 10) {
@@ -64,4 +62,4 @@ export default async (req: Request): Promise<Response> => {
 	);
 
 	return jsonResponse(relationships.map(r => relationshipToAPI(r)));
-};
+});
diff --git a/server/api/api/v1/accounts/search/index.ts b/server/api/api/v1/accounts/search/index.ts
index 5ec36528..15c6b529 100644
--- a/server/api/api/v1/accounts/search/index.ts
+++ b/server/api/api/v1/accounts/search/index.ts
@@ -1,11 +1,6 @@
 import { errorResponse, jsonResponse } from "@response";
-import {
-	getFromRequest,
-	userRelations,
-	userToAPI,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
-import { parseRequest } from "@request";
+import { userRelations, userToAPI } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -20,10 +15,16 @@ export const meta = applyConfig({
 	},
 });
 
-export default async (req: Request): Promise<Response> => {
+export default apiRoute<{
+	q?: string;
+	limit?: number;
+	offset?: number;
+	resolve?: boolean;
+	following?: boolean;
+}>(async (req, matchedRoute, extraData) => {
 	// TODO: Add checks for disabled or not email verified accounts
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -32,13 +33,7 @@ export default async (req: Request): Promise<Response> => {
 		limit = 40,
 		offset,
 		q,
-	} = await parseRequest<{
-		q?: string;
-		limit?: number;
-		offset?: number;
-		resolve?: boolean;
-		following?: boolean;
-	}>(req);
+	} = extraData.parsedRequest;
 
 	if (limit < 1 || limit > 80) {
 		return errorResponse("Limit must be between 1 and 80", 400);
@@ -48,19 +43,25 @@ export default async (req: Request): Promise<Response> => {
 
 	const accounts = await client.user.findMany({
 		where: {
-			displayName: {
-				contains: q,
-			},
-			username: {
-				contains: q,
-			},
+			OR: [
+				{
+					displayName: {
+						contains: q,
+					},
+				},
+				{
+					username: {
+						contains: q,
+					},
+				},
+			],
 			relationshipSubjects: following
 				? {
 						some: {
 							ownerId: user.id,
 							following,
 						},
-				  }
+					}
 				: undefined,
 		},
 		take: Number(limit),
@@ -69,4 +70,4 @@ export default async (req: Request): Promise<Response> => {
 	});
 
 	return jsonResponse(accounts.map(acct => userToAPI(acct)));
-};
+});
diff --git a/server/api/api/v1/accounts/update_credentials/index.ts b/server/api/api/v1/accounts/update_credentials/index.ts
index ee54270f..4a48807f 100644
--- a/server/api/api/v1/accounts/update_credentials/index.ts
+++ b/server/api/api/v1/accounts/update_credentials/index.ts
@@ -1,14 +1,18 @@
-import { getConfig } from "@config";
-import { parseRequest } from "@request";
 import { errorResponse, jsonResponse } from "@response";
-import { getFromRequest, userToAPI } from "~database/entities/User";
-import { applyConfig } from "@api";
+import { userRelations, userToAPI } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { sanitize } from "isomorphic-dompurify";
 import { sanitizeHtml } from "@sanitization";
-import { uploadFile } from "~classes/media";
 import ISO6391 from "iso-639-1";
 import { parseEmojis } from "~database/entities/Emoji";
 import { client } from "~database/datasource";
+import type { APISource } from "~types/entities/source";
+import { convertTextToHtml } from "@formatting";
+import { MediaBackendType } from "media-manager";
+import type { MediaBackend } from "media-manager";
+import { LocalMediaBackend } from "~packages/media-manager/backends/local";
+import { S3MediaBackend } from "~packages/media-manager/backends/s3";
+import { getUrl } from "~database/entities/Attachment";
 
 export const meta = applyConfig({
 	allowedMethods: ["PATCH"],
@@ -22,15 +26,23 @@ export const meta = applyConfig({
 	},
 });
 
-/**
- * Patches a user
- */
-export default async (req: Request): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute<{
+	display_name: string;
+	note: string;
+	avatar: File;
+	header: File;
+	locked: string;
+	bot: string;
+	discoverable: string;
+	"source[privacy]": string;
+	"source[sensitive]": string;
+	"source[language]": string;
+}>(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
-	const config = getConfig();
+	const config = await extraData.configManager.getConfig();
 
 	const {
 		display_name,
@@ -43,26 +55,38 @@ export default async (req: Request): Promise<Response> => {
 		"source[privacy]": source_privacy,
 		"source[sensitive]": source_sensitive,
 		"source[language]": source_language,
-	} = await parseRequest<{
-		display_name: string;
-		note: string;
-		avatar: File;
-		header: File;
-		locked: string;
-		bot: string;
-		discoverable: string;
-		"source[privacy]": string;
-		"source[sensitive]": string;
-		"source[language]": string;
-	}>(req);
+	} = extraData.parsedRequest;
 
 	const sanitizedNote = await sanitizeHtml(note ?? "");
 
-	const sanitizedDisplayName = sanitize(display_name, {
+	const sanitizedDisplayName = sanitize(display_name ?? "", {
 		ALLOWED_TAGS: [],
 		ALLOWED_ATTR: [],
 	});
 
+	if (!user.source) {
+		user.source = {
+			privacy: "public",
+			sensitive: false,
+			language: "en",
+			note: "",
+		};
+	}
+
+	let mediaManager: MediaBackend;
+
+	switch (config.media.backend as MediaBackendType) {
+		case MediaBackendType.LOCAL:
+			mediaManager = new LocalMediaBackend(config);
+			break;
+		case MediaBackendType.S3:
+			mediaManager = new S3MediaBackend(config);
+			break;
+		default:
+			// TODO: Replace with logger
+			throw new Error("Invalid media backend");
+	}
+
 	if (display_name) {
 		// Check if within allowed display name lengths
 		if (
@@ -90,7 +114,7 @@ export default async (req: Request): Promise<Response> => {
 		user.displayName = sanitizedDisplayName;
 	}
 
-	if (note) {
+	if (note && user.source) {
 		// Check if within allowed note length
 		if (sanitizedNote.length > config.validation.max_note_size) {
 			return errorResponse(
@@ -108,10 +132,9 @@ export default async (req: Request): Promise<Response> => {
 			return errorResponse("Bio contains blocked words", 422);
 		}
 
-		// Remove emojis
-		user.emojis = [];
-
-		user.note = sanitizedNote;
+		(user.source as unknown as APISource).note = sanitizedNote;
+		// TODO: Convert note to HTML
+		user.note = await convertTextToHtml(sanitizedNote);
 	}
 
 	if (source_privacy && user.source) {
@@ -127,8 +150,8 @@ export default async (req: Request): Promise<Response> => {
 			);
 		}
 
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-		(user.source as any).privacy = source_privacy;
+		// @ts-expect-error Prisma Typescript doesn't include relations
+		user.source.privacy = source_privacy;
 	}
 
 	if (source_sensitive && user.source) {
@@ -137,8 +160,8 @@ export default async (req: Request): Promise<Response> => {
 			return errorResponse("Sensitive must be a boolean", 422);
 		}
 
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-		(user.source as any).sensitive = source_sensitive === "true";
+		// @ts-expect-error Prisma Typescript doesn't include relations
+		user.source.sensitive = source_sensitive === "true";
 	}
 
 	if (source_language && user.source) {
@@ -149,8 +172,8 @@ export default async (req: Request): Promise<Response> => {
 			);
 		}
 
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-		(user.source as any).language = source_language;
+		// @ts-expect-error Prisma Typescript doesn't include relations
+		user.source.language = source_language;
 	}
 
 	if (avatar) {
@@ -162,9 +185,9 @@ export default async (req: Request): Promise<Response> => {
 			);
 		}
 
-		const hash = await uploadFile(avatar, config);
+		const { uploadedFile } = await mediaManager.addFile(avatar);
 
-		user.avatar = hash || "";
+		user.avatar = getUrl(uploadedFile.name, config);
 	}
 
 	if (header) {
@@ -176,9 +199,9 @@ export default async (req: Request): Promise<Response> => {
 			);
 		}
 
-		const hash = await uploadFile(header, config);
+		const { uploadedFile } = await mediaManager.addFile(header);
 
-		user.header = hash || "";
+		user.header = getUrl(uploadedFile.name, config);
 	}
 
 	if (locked) {
@@ -220,7 +243,7 @@ export default async (req: Request): Promise<Response> => {
 		(emoji, index, self) => self.findIndex(e => e.id === emoji.id) === index
 	);
 
-	await client.user.update({
+	const output = await client.user.update({
 		where: { id: user.id },
 		data: {
 			displayName: user.displayName,
@@ -240,7 +263,8 @@ export default async (req: Request): Promise<Response> => {
 			},
 			source: user.source || undefined,
 		},
+		include: userRelations,
 	});
 
-	return jsonResponse(userToAPI(user));
-};
+	return jsonResponse(userToAPI(output));
+});
diff --git a/server/api/api/v1/accounts/verify_credentials/index.ts b/server/api/api/v1/accounts/verify_credentials/index.ts
index 94543895..e317389f 100644
--- a/server/api/api/v1/accounts/verify_credentials/index.ts
+++ b/server/api/api/v1/accounts/verify_credentials/index.ts
@@ -1,6 +1,6 @@
 import { errorResponse, jsonResponse } from "@response";
-import { getFromRequest, userToAPI } from "~database/entities/User";
-import { applyConfig } from "@api";
+import { userToAPI } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 
 export const meta = applyConfig({
 	allowedMethods: ["GET"],
@@ -14,14 +14,14 @@ export const meta = applyConfig({
 	},
 });
 
-export default async (req: Request): Promise<Response> => {
+export default apiRoute((req, matchedRoute, extraData) => {
 	// TODO: Add checks for disabled or not email verified accounts
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
 	return jsonResponse({
 		...userToAPI(user, true),
 	});
-};
+});
diff --git a/server/api/api/v1/apps/index.ts b/server/api/api/v1/apps/index.ts
index 175599f8..c3e3bff8 100644
--- a/server/api/api/v1/apps/index.ts
+++ b/server/api/api/v1/apps/index.ts
@@ -1,5 +1,4 @@
-import { applyConfig } from "@api";
-import { parseRequest } from "@request";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
 import { randomBytes } from "crypto";
 import { client } from "~database/datasource";
@@ -19,13 +18,14 @@ export const meta = applyConfig({
 /**
  * Creates a new application to obtain OAuth 2 credentials
  */
-export default async (req: Request): Promise<Response> => {
-	const { client_name, redirect_uris, scopes, website } = await parseRequest<{
-		client_name: string;
-		redirect_uris: string;
-		scopes: string;
-		website: string;
-	}>(req);
+export default apiRoute<{
+	client_name: string;
+	redirect_uris: string;
+	scopes: string;
+	website: string;
+}>(async (req, matchedRoute, extraData) => {
+	const { client_name, redirect_uris, scopes, website } =
+		extraData.parsedRequest;
 
 	// Check if redirect URI is a valid URI, and also an absolute URI
 	if (redirect_uris) {
@@ -62,4 +62,4 @@ export default async (req: Request): Promise<Response> => {
 		redirect_uri: application.redirect_uris,
 		vapid_link: application.vapid_key,
 	});
-};
+});
diff --git a/server/api/api/v1/apps/verify_credentials/index.ts b/server/api/api/v1/apps/verify_credentials/index.ts
index a281be66..4444213e 100644
--- a/server/api/api/v1/apps/verify_credentials/index.ts
+++ b/server/api/api/v1/apps/verify_credentials/index.ts
@@ -1,7 +1,6 @@
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
 import { getFromToken } from "~database/entities/Application";
-import { getFromRequest } from "~database/entities/User";
 
 export const meta = applyConfig({
 	allowedMethods: ["GET"],
@@ -18,8 +17,8 @@ export const meta = applyConfig({
 /**
  * Returns OAuth2 credentials
  */
-export default async (req: Request): Promise<Response> => {
-	const { user, token } = await getFromRequest(req);
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const { user, token } = extraData.auth;
 	const application = await getFromToken(token);
 
 	if (!user) return errorResponse("Unauthorized", 401);
@@ -32,4 +31,4 @@ export default async (req: Request): Promise<Response> => {
 		redirect_uris: application.redirect_uris,
 		scopes: application.scopes,
 	});
-};
+});
diff --git a/server/api/api/v1/blocks/index.ts b/server/api/api/v1/blocks/index.ts
index 99ee967f..0bbfa26b 100644
--- a/server/api/api/v1/blocks/index.ts
+++ b/server/api/api/v1/blocks/index.ts
@@ -1,10 +1,6 @@
 import { errorResponse, jsonResponse } from "@response";
-import {
-	getFromRequest,
-	userRelations,
-	userToAPI,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { userRelations, userToAPI } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -19,8 +15,8 @@ export const meta = applyConfig({
 	},
 });
 
-export default async (req: Request): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -37,4 +33,4 @@ export default async (req: Request): Promise<Response> => {
 	});
 
 	return jsonResponse(blocks.map(u => userToAPI(u)));
-};
+});
diff --git a/server/api/api/v1/custom_emojis/index.ts b/server/api/api/v1/custom_emojis/index.ts
index 1590bbc0..224da926 100644
--- a/server/api/api/v1/custom_emojis/index.ts
+++ b/server/api/api/v1/custom_emojis/index.ts
@@ -1,4 +1,4 @@
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { jsonResponse } from "@response";
 import { client } from "~database/datasource";
 import { emojiToAPI } from "~database/entities/Emoji";
@@ -15,11 +15,7 @@ export const meta = applyConfig({
 	},
 });
 
-/**
- * S
- */
-// eslint-disable-next-line @typescript-eslint/require-await
-export default async (): Promise<Response> => {
+export default apiRoute(async () => {
 	const emojis = await client.emoji.findMany({
 		where: {
 			instanceId: null,
@@ -29,4 +25,4 @@ export default async (): Promise<Response> => {
 	return jsonResponse(
 		await Promise.all(emojis.map(emoji => emojiToAPI(emoji)))
 	);
-};
+});
diff --git a/server/api/api/v1/favourites/index.ts b/server/api/api/v1/favourites/index.ts
index 55e0a672..7e0b1dbb 100644
--- a/server/api/api/v1/favourites/index.ts
+++ b/server/api/api/v1/favourites/index.ts
@@ -1,8 +1,6 @@
 import { errorResponse, jsonResponse } from "@response";
-import { getFromRequest } from "~database/entities/User";
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
-import { parseRequest } from "@request";
 import { statusAndUserRelations, statusToAPI } from "~database/entities/Status";
 
 export const meta = applyConfig({
@@ -17,20 +15,15 @@ export const meta = applyConfig({
 	},
 });
 
-export default async (req: Request): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute<{
+	max_id?: string;
+	since_id?: string;
+	min_id?: string;
+	limit?: number;
+}>(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
-	const {
-		limit = 20,
-		max_id,
-		min_id,
-		since_id,
-	} = await parseRequest<{
-		max_id?: string;
-		since_id?: string;
-		min_id?: string;
-		limit?: number;
-	}>(req);
+	const { limit = 20, max_id, min_id, since_id } = extraData.parsedRequest;
 
 	if (limit < 1 || limit > 40) {
 		return errorResponse("Limit must be between 1 and 40", 400);
@@ -77,4 +70,4 @@ export default async (req: Request): Promise<Response> => {
 			Link: linkHeader.join(", "),
 		}
 	);
-};
+});
diff --git a/server/api/api/v1/follow_requests/[account_id]/authorize.ts b/server/api/api/v1/follow_requests/[account_id]/authorize.ts
index 074aae92..874633da 100644
--- a/server/api/api/v1/follow_requests/[account_id]/authorize.ts
+++ b/server/api/api/v1/follow_requests/[account_id]/authorize.ts
@@ -1,8 +1,7 @@
 import { errorResponse, jsonResponse } from "@response";
-import { getFromRequest, userRelations } from "~database/entities/User";
-import { applyConfig } from "@api";
+import { userRelations } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
-import type { MatchedRoute } from "bun";
 import {
 	checkForBidirectionalRelationships,
 	relationshipToAPI,
@@ -20,11 +19,8 @@ export const meta = applyConfig({
 	},
 });
 
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -76,4 +72,4 @@ export default async (
 	if (!relationship) return errorResponse("Relationship not found", 404);
 
 	return jsonResponse(relationshipToAPI(relationship));
-};
+});
diff --git a/server/api/api/v1/follow_requests/[account_id]/reject.ts b/server/api/api/v1/follow_requests/[account_id]/reject.ts
index 6a667e79..41d4105c 100644
--- a/server/api/api/v1/follow_requests/[account_id]/reject.ts
+++ b/server/api/api/v1/follow_requests/[account_id]/reject.ts
@@ -1,8 +1,7 @@
 import { errorResponse, jsonResponse } from "@response";
-import { getFromRequest, userRelations } from "~database/entities/User";
-import { applyConfig } from "@api";
+import { userRelations } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
-import type { MatchedRoute } from "bun";
 import {
 	checkForBidirectionalRelationships,
 	relationshipToAPI,
@@ -20,11 +19,8 @@ export const meta = applyConfig({
 	},
 });
 
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -64,4 +60,4 @@ export default async (
 	if (!relationship) return errorResponse("Relationship not found", 404);
 
 	return jsonResponse(relationshipToAPI(relationship));
-};
+});
diff --git a/server/api/api/v1/follow_requests/index.ts b/server/api/api/v1/follow_requests/index.ts
index d465c61d..ac937d46 100644
--- a/server/api/api/v1/follow_requests/index.ts
+++ b/server/api/api/v1/follow_requests/index.ts
@@ -1,12 +1,7 @@
 import { errorResponse, jsonResponse } from "@response";
-import {
-	getFromRequest,
-	userRelations,
-	userToAPI,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { userRelations, userToAPI } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
-import { parseRequest } from "@request";
 
 export const meta = applyConfig({
 	allowedMethods: ["GET"],
@@ -20,20 +15,15 @@ export const meta = applyConfig({
 	},
 });
 
-export default async (req: Request): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute<{
+	max_id?: string;
+	since_id?: string;
+	min_id?: string;
+	limit?: number;
+}>(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
-	const {
-		limit = 20,
-		max_id,
-		min_id,
-		since_id,
-	} = await parseRequest<{
-		max_id?: string;
-		since_id?: string;
-		min_id?: string;
-		limit?: number;
-	}>(req);
+	const { limit = 20, max_id, min_id, since_id } = extraData.parsedRequest;
 
 	if (limit < 1 || limit > 40) {
 		return errorResponse("Limit must be between 1 and 40", 400);
@@ -79,4 +69,4 @@ export default async (req: Request): Promise<Response> => {
 			Link: linkHeader.join(", "),
 		}
 	);
-};
+});
diff --git a/server/api/api/v1/instance/index.ts b/server/api/api/v1/instance/index.ts
index d9a87537..4fabefd0 100644
--- a/server/api/api/v1/instance/index.ts
+++ b/server/api/api/v1/instance/index.ts
@@ -1,5 +1,4 @@
-import { applyConfig } from "@api";
-import { getConfig } from "@config";
+import { apiRoute, applyConfig } from "@api";
 import { jsonResponse } from "@response";
 import { client } from "~database/datasource";
 import { userRelations, userToAPI } from "~database/entities/User";
@@ -18,12 +17,8 @@ export const meta = applyConfig({
 	},
 });
 
-/**
- * Creates a new user
- */
-// eslint-disable-next-line @typescript-eslint/require-await
-export default async (): Promise<Response> => {
-	const config = getConfig();
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const config = await extraData.configManager.getConfig();
 
 	// Get software version from package.json
 	const version = manifest.version;
@@ -101,15 +96,19 @@ export default async (): Promise<Response> => {
 		description: "A test instance",
 		email: "",
 		invites_enabled: false,
-		registrations: true,
+		registrations: config.signups.registration,
 		languages: ["en"],
-		rules: [],
+		rules: config.signups.rules.map((r, index) => ({
+			id: String(index),
+			text: r,
+		})),
 		stats: {
 			domain_count: knownDomainsCount,
 			status_count: statusCount,
 			user_count: userCount,
 		},
 		thumbnail: "",
+		tos_url: config.signups.tos_url,
 		title: "Test Instance",
 		uri: new URL(config.http.base_url).hostname,
 		urls: {
@@ -155,4 +154,4 @@ export default async (): Promise<Response> => {
 		},
 		contact_account: contactAccount ? userToAPI(contactAccount) : null,
 	} as APIInstance);
-};
+});
diff --git a/server/api/api/v1/media/[id]/index.ts b/server/api/api/v1/media/[id]/index.ts
index cc4c8e3c..8abd1bf0 100644
--- a/server/api/api/v1/media/[id]/index.ts
+++ b/server/api/api/v1/media/[id]/index.ts
@@ -1,15 +1,13 @@
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
 import { client } from "~database/datasource";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
-import { uploadFile } from "~classes/media";
-import { getConfig } from "@config";
 import { attachmentToAPI, getUrl } from "~database/entities/Attachment";
-import type { MatchedRoute } from "bun";
-import { parseRequest } from "@request";
+import type { MediaBackend } from "media-manager";
+import { MediaBackendType } from "media-manager";
+import { LocalMediaBackend } from "~packages/media-manager/backends/local";
+import { S3MediaBackend } from "~packages/media-manager/backends/s3";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["GET", "PUT"],
 	ratelimits: {
 		max: 10,
@@ -25,11 +23,12 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Get media information
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute<{
+	thumbnail?: File;
+	description?: string;
+	focus?: string;
+}>(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
 	if (!user) {
 		return errorResponse("Unauthorized", 401);
@@ -47,7 +46,7 @@ export default async (
 		return errorResponse("Media not found", 404);
 	}
 
-	const config = getConfig();
+	const config = await extraData.configManager.getConfig();
 
 	switch (req.method) {
 		case "GET": {
@@ -60,21 +59,27 @@ export default async (
 			}
 		}
 		case "PUT": {
-			const { description, thumbnail } = await parseRequest<{
-				thumbnail?: File;
-				description?: string;
-				focus?: string;
-			}>(req);
+			const { description, thumbnail } = extraData.parsedRequest;
 
 			let thumbnailUrl = attachment.thumbnail_url;
 
-			if (thumbnail) {
-				const hash = await uploadFile(
-					thumbnail as unknown as File,
-					config
-				);
+			let mediaManager: MediaBackend;
 
-				thumbnailUrl = hash ? getUrl(hash, config) : "";
+			switch (config.media.backend as MediaBackendType) {
+				case MediaBackendType.LOCAL:
+					mediaManager = new LocalMediaBackend(config);
+					break;
+				case MediaBackendType.S3:
+					mediaManager = new S3MediaBackend(config);
+					break;
+				default:
+					// TODO: Replace with logger
+					throw new Error("Invalid media backend");
+			}
+
+			if (thumbnail) {
+				const { uploadedFile } = await mediaManager.addFile(thumbnail);
+				thumbnailUrl = getUrl(uploadedFile.name, config);
 			}
 
 			const descriptionText = description || attachment.description;
@@ -101,4 +106,4 @@ export default async (
 	}
 
 	return errorResponse("Method not allowed", 405);
-};
+});
diff --git a/server/api/api/v1/media/index.ts b/server/api/api/v1/media/index.ts
index da3019ef..202e5dbb 100644
--- a/server/api/api/v1/media/index.ts
+++ b/server/api/api/v1/media/index.ts
@@ -1,15 +1,15 @@
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
 import { client } from "~database/datasource";
 import { encode } from "blurhash";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
 import sharp from "sharp";
-import { uploadFile } from "~classes/media";
-import { getConfig } from "@config";
 import { attachmentToAPI, getUrl } from "~database/entities/Attachment";
+import { MediaBackendType } from "media-manager";
+import type { MediaBackend } from "media-manager";
+import { LocalMediaBackend } from "~packages/media-manager/backends/local";
+import { S3MediaBackend } from "~packages/media-manager/backends/s3";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["POST"],
 	ratelimits: {
 		max: 10,
@@ -25,27 +25,26 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Upload new media
  */
-export default async (req: Request): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute<{
+	file: File;
+	thumbnail?: File;
+	description?: string;
+	// TODO: Add focus
+	focus?: string;
+}>(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
 	if (!user) {
 		return errorResponse("Unauthorized", 401);
 	}
 
-	const form = await req.formData();
-
-	const file = form.get("file") as unknown as File | undefined;
-	const thumbnail = form.get("thumbnail");
-	const description = form.get("description") as string | undefined;
-
-	// Floating point numbers from -1.0 to 1.0, comma delimited
-	// const focus = form.get("focus");
+	const { file, thumbnail, description } = extraData.parsedRequest;
 
 	if (!file) {
 		return errorResponse("No file provided", 400);
 	}
 
-	const config = getConfig();
+	const config = await extraData.configManager.getConfig();
 
 	if (file.size > config.validation.max_media_size) {
 		return errorResponse(
@@ -86,21 +85,35 @@ export default async (req: Request): Promise<Response> => {
 				metadata?.height ?? 0,
 				4,
 				4
-		  )
+			)
 		: null;
 
 	let url = "";
 
-	const hash = await uploadFile(file, config);
+	let mediaManager: MediaBackend;
 
-	url = hash ? getUrl(hash, config) : "";
+	switch (config.media.backend as MediaBackendType) {
+		case MediaBackendType.LOCAL:
+			mediaManager = new LocalMediaBackend(config);
+			break;
+		case MediaBackendType.S3:
+			mediaManager = new S3MediaBackend(config);
+			break;
+		default:
+			// TODO: Replace with logger
+			throw new Error("Invalid media backend");
+	}
+
+	const { uploadedFile } = await mediaManager.addFile(file);
+
+	url = getUrl(uploadedFile.name, config);
 
 	let thumbnailUrl = "";
 
 	if (thumbnail) {
-		const hash = await uploadFile(thumbnail as unknown as File, config);
+		const { uploadedFile } = await mediaManager.addFile(thumbnail);
 
-		thumbnailUrl = hash ? getUrl(hash, config) : "";
+		thumbnailUrl = getUrl(uploadedFile.name, config);
 	}
 
 	const newAttachment = await client.attachment.create({
@@ -120,4 +133,4 @@ export default async (req: Request): Promise<Response> => {
 	// TODO: Add job to process videos and other media
 
 	return jsonResponse(attachmentToAPI(newAttachment));
-};
+});
diff --git a/server/api/api/v1/moderation/accounts/search/index.ts b/server/api/api/v1/moderation/accounts/search/index.ts
new file mode 100644
index 00000000..e69de29b
diff --git a/server/api/api/v1/mutes/index.ts b/server/api/api/v1/mutes/index.ts
index dfa48057..702cc434 100644
--- a/server/api/api/v1/mutes/index.ts
+++ b/server/api/api/v1/mutes/index.ts
@@ -1,10 +1,6 @@
 import { errorResponse, jsonResponse } from "@response";
-import {
-	getFromRequest,
-	userRelations,
-	userToAPI,
-} from "~database/entities/User";
-import { applyConfig } from "@api";
+import { userRelations, userToAPI } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 
 export const meta = applyConfig({
@@ -19,8 +15,8 @@ export const meta = applyConfig({
 	},
 });
 
-export default async (req: Request): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -37,4 +33,4 @@ export default async (req: Request): Promise<Response> => {
 	});
 
 	return jsonResponse(blocks.map(u => userToAPI(u)));
-};
+});
diff --git a/server/api/api/v1/notifications/index.ts b/server/api/api/v1/notifications/index.ts
index b5eb1c3b..b8971a27 100644
--- a/server/api/api/v1/notifications/index.ts
+++ b/server/api/api/v1/notifications/index.ts
@@ -1,9 +1,8 @@
 import { errorResponse, jsonResponse } from "@response";
-import { getFromRequest, userRelations } from "~database/entities/User";
-import { applyConfig } from "@api";
+import { userRelations } from "~database/entities/User";
+import { apiRoute, applyConfig } from "@api";
 import { client } from "~database/datasource";
 import { statusAndUserRelations } from "~database/entities/Status";
-import { parseRequest } from "@request";
 import { notificationToAPI } from "~database/entities/Notification";
 
 export const meta = applyConfig({
@@ -18,8 +17,16 @@ export const meta = applyConfig({
 	},
 });
 
-export default async (req: Request): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute<{
+	max_id?: string;
+	since_id?: string;
+	min_id?: string;
+	limit?: number;
+	exclude_types?: string[];
+	types?: string[];
+	account_id?: string;
+}>(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -31,15 +38,7 @@ export default async (req: Request): Promise<Response> => {
 		min_id,
 		since_id,
 		types,
-	} = await parseRequest<{
-		max_id?: string;
-		since_id?: string;
-		min_id?: string;
-		limit?: number;
-		exclude_types?: string[];
-		types?: string[];
-		account_id?: string;
-	}>(req);
+	} = extraData.parsedRequest;
 
 	if (limit > 30) return errorResponse("Limit too high", 400);
 
@@ -85,8 +84,9 @@ export default async (req: Request): Promise<Response> => {
 			`<${urlWithoutQuery}?max_id=${objects[0].id}&limit=${limit}>; rel="next"`
 		);
 		linkHeader.push(
-			`<${urlWithoutQuery}?since_id=${objects.at(-1)
-				?.id}&limit=${limit}>; rel="prev"`
+			`<${urlWithoutQuery}?since_id=${
+				objects.at(-1)?.id
+			}&limit=${limit}>; rel="prev"`
 		);
 	}
 
@@ -97,4 +97,4 @@ export default async (req: Request): Promise<Response> => {
 			Link: linkHeader.join(", "),
 		}
 	);
-};
+});
diff --git a/server/api/api/v1/profile/avatar.ts b/server/api/api/v1/profile/avatar.ts
index c263718d..f6a1ea47 100644
--- a/server/api/api/v1/profile/avatar.ts
+++ b/server/api/api/v1/profile/avatar.ts
@@ -1,14 +1,9 @@
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
 import { client } from "~database/datasource";
-import {
-	getFromRequest,
-	userRelations,
-	userToAPI,
-} from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
+import { userRelations, userToAPI } from "~database/entities/User";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["DELETE"],
 	ratelimits: {
 		max: 10,
@@ -23,8 +18,8 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Deletes a user avatar
  */
-export default async (req: Request): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -40,4 +35,4 @@ export default async (req: Request): Promise<Response> => {
 	});
 
 	return jsonResponse(userToAPI(newUser));
-};
+});
diff --git a/server/api/api/v1/profile/header.ts b/server/api/api/v1/profile/header.ts
index 9c9f9ec3..b3b52a60 100644
--- a/server/api/api/v1/profile/header.ts
+++ b/server/api/api/v1/profile/header.ts
@@ -1,14 +1,9 @@
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
 import { client } from "~database/datasource";
-import {
-	getFromRequest,
-	userRelations,
-	userToAPI,
-} from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
+import { userRelations, userToAPI } from "~database/entities/User";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["DELETE"],
 	ratelimits: {
 		max: 10,
@@ -23,8 +18,8 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Deletes a user header
  */
-export default async (req: Request): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -40,4 +35,4 @@ export default async (req: Request): Promise<Response> => {
 	});
 
 	return jsonResponse(userToAPI(newUser));
-};
+});
diff --git a/server/api/api/v1/statuses/[id]/context.ts b/server/api/api/v1/statuses/[id]/context.ts
index ab9aadab..93eed932 100644
--- a/server/api/api/v1/statuses/[id]/context.ts
+++ b/server/api/api/v1/statuses/[id]/context.ts
@@ -1,6 +1,5 @@
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import { client } from "~database/datasource";
 import {
 	getAncestors,
@@ -8,10 +7,8 @@ import {
 	statusAndUserRelations,
 	statusToAPI,
 } from "~database/entities/Status";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["GET"],
 	ratelimits: {
 		max: 8,
@@ -26,15 +23,12 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Fetch a user
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	// Public for public statuses limited to 40 ancestors and 60 descendants with a maximum depth of 20.
 	// User token + read:statuses for up to 4,096 ancestors, 4,096 descendants, unlimited depth, and private statuses.
 	const id = matchedRoute.params.id;
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	const foundStatus = await client.status.findUnique({
 		where: { id },
@@ -55,4 +49,4 @@ export default async (
 			descendants.map(status => statusToAPI(status, user || undefined))
 		),
 	});
-};
+});
diff --git a/server/api/api/v1/statuses/[id]/favourite.ts b/server/api/api/v1/statuses/[id]/favourite.ts
index d1f8c39a..c58e959e 100644
--- a/server/api/api/v1/statuses/[id]/favourite.ts
+++ b/server/api/api/v1/statuses/[id]/favourite.ts
@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import { client } from "~database/datasource";
 import { createLike } from "~database/entities/Like";
 import {
@@ -9,11 +8,9 @@ import {
 	statusAndUserRelations,
 	statusToAPI,
 } from "~database/entities/Status";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
 import type { APIStatus } from "~types/entities/status";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["POST"],
 	ratelimits: {
 		max: 100,
@@ -28,13 +25,10 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Favourite a post
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -63,4 +57,4 @@ export default async (
 		favourited: true,
 		favourites_count: status._count.likes + 1,
 	} as APIStatus);
-};
+});
diff --git a/server/api/api/v1/statuses/[id]/favourited_by.ts b/server/api/api/v1/statuses/[id]/favourited_by.ts
index edbb0fdc..066eb681 100644
--- a/server/api/api/v1/statuses/[id]/favourited_by.ts
+++ b/server/api/api/v1/statuses/[id]/favourited_by.ts
@@ -1,21 +1,13 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { applyConfig } from "@api";
-import { parseRequest } from "@request";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import { client } from "~database/datasource";
 import {
 	isViewableByUser,
 	statusAndUserRelations,
 } from "~database/entities/Status";
-import {
-	getFromRequest,
-	userRelations,
-	userToAPI,
-} from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
+import { userRelations, userToAPI } from "~database/entities/User";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["GET"],
 	ratelimits: {
 		max: 100,
@@ -30,13 +22,15 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Fetch users who favourited the post
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute<{
+	max_id?: string;
+	min_id?: string;
+	since_id?: string;
+	limit?: number;
+}>(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	const status = await client.status.findUnique({
 		where: { id },
@@ -52,12 +46,7 @@ export default async (
 		min_id = null,
 		since_id = null,
 		limit = 40,
-	} = await parseRequest<{
-		max_id?: string;
-		min_id?: string;
-		since_id?: string;
-		limit?: number;
-	}>(req);
+	} = extraData.parsedRequest;
 
 	// Check for limit limits
 	if (limit > 80) return errorResponse("Invalid limit (maximum is 80)", 400);
@@ -111,4 +100,4 @@ export default async (
 			Link: linkHeader.join(", "),
 		}
 	);
-};
+});
diff --git a/server/api/api/v1/statuses/[id]/index.ts b/server/api/api/v1/statuses/[id]/index.ts
index ad7b7cee..8dfdc8b7 100644
--- a/server/api/api/v1/statuses/[id]/index.ts
+++ b/server/api/api/v1/statuses/[id]/index.ts
@@ -1,17 +1,17 @@
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
+import { sanitizeHtml } from "@sanitization";
+import { parse } from "marked";
 import { client } from "~database/datasource";
 import {
+	editStatus,
 	isViewableByUser,
 	statusAndUserRelations,
 	statusToAPI,
 } from "~database/entities/Status";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
 
-export const meta: APIRouteMeta = applyConfig({
-	allowedMethods: ["GET", "DELETE"],
+export const meta = applyConfig({
+	allowedMethods: ["GET", "DELETE", "PUT"],
 	ratelimits: {
 		max: 100,
 		duration: 60,
@@ -19,26 +19,36 @@ export const meta: APIRouteMeta = applyConfig({
 	route: "/api/v1/statuses/:id",
 	auth: {
 		required: false,
-		requiredOnMethods: ["DELETE"],
+		requiredOnMethods: ["DELETE", "PUT"],
 	},
 });
 
 /**
  * Fetch a user
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute<{
+	status?: string;
+	spoiler_text?: string;
+	sensitive?: boolean;
+	language?: string;
+	content_type?: string;
+	media_ids?: string[];
+	"poll[options]"?: string[];
+	"poll[expires_in]"?: number;
+	"poll[multiple]"?: boolean;
+	"poll[hide_totals]"?: boolean;
+}>(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	const status = await client.status.findUnique({
 		where: { id },
 		include: statusAndUserRelations,
 	});
 
+	const config = await extraData.configManager.getConfig();
+
 	// Check if user is authorized to view this status (if it's private)
 	if (!status || !isViewableByUser(status, user))
 		return errorResponse("Record not found", 404);
@@ -69,7 +79,140 @@ export default async (
 			},
 			200
 		);
+	} else if (req.method == "PUT") {
+		if (status.authorId !== user?.id) {
+			return errorResponse("Unauthorized", 401);
+		}
+
+		const {
+			status: statusText,
+			content_type,
+			"poll[expires_in]": expires_in,
+			"poll[options]": options,
+			media_ids: media_ids,
+			spoiler_text,
+			sensitive,
+		} = extraData.parsedRequest;
+
+		// TODO: Add Poll support
+		// Validate status
+		if (!statusText && !(media_ids && media_ids.length > 0)) {
+			return errorResponse(
+				"Status is required unless media is attached",
+				422
+			);
+		}
+
+		// Validate media_ids
+		if (media_ids && !Array.isArray(media_ids)) {
+			return errorResponse("Media IDs must be an array", 422);
+		}
+
+		// Validate poll options
+		if (options && !Array.isArray(options)) {
+			return errorResponse("Poll options must be an array", 422);
+		}
+
+		if (options && options.length > 4) {
+			return errorResponse("Poll options must be less than 5", 422);
+		}
+
+		if (media_ids && media_ids.length > 0) {
+			// Disallow poll
+			if (options) {
+				return errorResponse("Cannot attach poll to media", 422);
+			}
+			if (media_ids.length > 4) {
+				return errorResponse("Media IDs must be less than 5", 422);
+			}
+		}
+
+		if (options && options.length > config.validation.max_poll_options) {
+			return errorResponse(
+				`Poll options must be less than ${config.validation.max_poll_options}`,
+				422
+			);
+		}
+
+		if (
+			options &&
+			options.some(
+				option => option.length > config.validation.max_poll_option_size
+			)
+		) {
+			return errorResponse(
+				`Poll options must be less than ${config.validation.max_poll_option_size} characters`,
+				422
+			);
+		}
+
+		if (expires_in && expires_in < config.validation.min_poll_duration) {
+			return errorResponse(
+				`Poll duration must be greater than ${config.validation.min_poll_duration} seconds`,
+				422
+			);
+		}
+
+		if (expires_in && expires_in > config.validation.max_poll_duration) {
+			return errorResponse(
+				`Poll duration must be less than ${config.validation.max_poll_duration} seconds`,
+				422
+			);
+		}
+
+		let sanitizedStatus: string;
+
+		if (content_type === "text/markdown") {
+			sanitizedStatus = await sanitizeHtml(await parse(statusText ?? ""));
+		} else if (content_type === "text/x.misskeymarkdown") {
+			// Parse as MFM
+			// TODO: Parse as MFM
+			sanitizedStatus = await sanitizeHtml(await parse(statusText ?? ""));
+		} else {
+			sanitizedStatus = await sanitizeHtml(statusText ?? "");
+		}
+
+		if (sanitizedStatus.length > config.validation.max_note_size) {
+			return errorResponse(
+				`Status must be less than ${config.validation.max_note_size} characters`,
+				400
+			);
+		}
+
+		// Check if status body doesnt match filters
+		if (
+			config.filters.note_filters.some(filter =>
+				statusText?.match(filter)
+			)
+		) {
+			return errorResponse("Status contains blocked words", 422);
+		}
+
+		// Check if media attachments are all valid
+
+		const foundAttachments = await client.attachment.findMany({
+			where: {
+				id: {
+					in: media_ids ?? [],
+				},
+			},
+		});
+
+		if (foundAttachments.length !== (media_ids ?? []).length) {
+			return errorResponse("Invalid media IDs", 422);
+		}
+
+		// Update status
+		const newStatus = await editStatus(status, {
+			content: sanitizedStatus,
+			content_type,
+			media_attachments: media_ids,
+			spoiler_text: spoiler_text ?? "",
+			sensitive: sensitive ?? false,
+		});
+
+		return jsonResponse(await statusToAPI(newStatus, user));
 	}
 
 	return jsonResponse({});
-};
+});
diff --git a/server/api/api/v1/statuses/[id]/pin.ts b/server/api/api/v1/statuses/[id]/pin.ts
index 72eceee6..fd215f46 100644
--- a/server/api/api/v1/statuses/[id]/pin.ts
+++ b/server/api/api/v1/statuses/[id]/pin.ts
@@ -1,13 +1,10 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import { client } from "~database/datasource";
 import { statusAndUserRelations, statusToAPI } from "~database/entities/Status";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["POST"],
 	ratelimits: {
 		max: 100,
@@ -22,13 +19,10 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Pin a post
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -62,4 +56,4 @@ export default async (
 	if (!status) return errorResponse("Record not found", 404);
 
 	return jsonResponse(statusToAPI(status, user));
-};
+});
diff --git a/server/api/api/v1/statuses/[id]/reblog.ts b/server/api/api/v1/statuses/[id]/reblog.ts
index dc67ee8d..73b0ef73 100644
--- a/server/api/api/v1/statuses/[id]/reblog.ts
+++ b/server/api/api/v1/statuses/[id]/reblog.ts
@@ -1,22 +1,15 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { applyConfig } from "@api";
-import { getConfig } from "@config";
-import { parseRequest } from "@request";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import { client } from "~database/datasource";
 import {
 	isViewableByUser,
 	statusAndUserRelations,
 	statusToAPI,
 } from "~database/entities/Status";
-import {
-	getFromRequest,
-	type UserWithRelations,
-} from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
+import { type UserWithRelations } from "~database/entities/User";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["POST"],
 	ratelimits: {
 		max: 100,
@@ -31,20 +24,17 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Reblogs a post
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute<{
+	visibility: "public" | "unlisted" | "private";
+}>(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
-	const config = getConfig();
+	const config = await extraData.configManager.getConfig();
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
-	const { visibility = "public" } = await parseRequest<{
-		visibility: "public" | "unlisted" | "private";
-	}>(req);
+	const { visibility = "public" } = extraData.parsedRequest;
 
 	const status = await client.status.findUnique({
 		where: { id },
@@ -87,16 +77,11 @@ export default async (
 	});
 
 	// Create notification for reblog if reblogged user is on the same instance
-	if (
-		// @ts-expect-error Prisma relations not showing in types
-		(status.reblog?.author as UserWithRelations).instanceId ===
-		user.instanceId
-	) {
+	if ((status.author as UserWithRelations).instanceId === user.instanceId) {
 		await client.notification.create({
 			data: {
 				accountId: user.id,
-				// @ts-expect-error Prisma relations not showing in types
-				notifiedId: status.reblog.authorId,
+				notifiedId: status.authorId,
 				type: "reblog",
 				statusId: status.reblogId,
 			},
@@ -112,4 +97,4 @@ export default async (
 			user
 		)
 	);
-};
+});
diff --git a/server/api/api/v1/statuses/[id]/reblogged_by.ts b/server/api/api/v1/statuses/[id]/reblogged_by.ts
index d51fa975..b02a02a2 100644
--- a/server/api/api/v1/statuses/[id]/reblogged_by.ts
+++ b/server/api/api/v1/statuses/[id]/reblogged_by.ts
@@ -1,21 +1,13 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { applyConfig } from "@api";
-import { parseRequest } from "@request";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import { client } from "~database/datasource";
 import {
 	isViewableByUser,
 	statusAndUserRelations,
 } from "~database/entities/Status";
-import {
-	getFromRequest,
-	userRelations,
-	userToAPI,
-} from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
+import { userRelations, userToAPI } from "~database/entities/User";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["GET"],
 	ratelimits: {
 		max: 100,
@@ -30,13 +22,15 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Fetch users who reblogged the post
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute<{
+	max_id?: string;
+	min_id?: string;
+	since_id?: string;
+	limit?: number;
+}>(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	const status = await client.status.findUnique({
 		where: { id },
@@ -52,12 +46,7 @@ export default async (
 		min_id = null,
 		since_id = null,
 		limit = 40,
-	} = await parseRequest<{
-		max_id?: string;
-		min_id?: string;
-		since_id?: string;
-		limit?: number;
-	}>(req);
+	} = extraData.parsedRequest;
 
 	// Check for limit limits
 	if (limit > 80) return errorResponse("Invalid limit (maximum is 80)", 400);
@@ -112,4 +101,4 @@ export default async (
 			Link: linkHeader.join(", "),
 		}
 	);
-};
+});
diff --git a/server/api/api/v1/statuses/[id]/source.ts b/server/api/api/v1/statuses/[id]/source.ts
new file mode 100644
index 00000000..5bb90600
--- /dev/null
+++ b/server/api/api/v1/statuses/[id]/source.ts
@@ -0,0 +1,41 @@
+import { apiRoute, applyConfig } from "@api";
+import { errorResponse } from "@response";
+import { client } from "~database/datasource";
+import {
+	isViewableByUser,
+	statusAndUserRelations,
+} from "~database/entities/Status";
+
+export const meta = applyConfig({
+	allowedMethods: ["GET"],
+	ratelimits: {
+		max: 100,
+		duration: 60,
+	},
+	route: "/api/v1/statuses/:id/source",
+	auth: {
+		required: true,
+	},
+});
+
+/**
+ * Favourite a post
+ */
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const id = matchedRoute.params.id;
+
+	const { user } = extraData.auth;
+
+	if (!user) return errorResponse("Unauthorized", 401);
+
+	const status = await client.status.findUnique({
+		where: { id },
+		include: statusAndUserRelations,
+	});
+
+	// Check if user is authorized to view this status (if it's private)
+	if (!status || !isViewableByUser(status, user))
+		return errorResponse("Record not found", 404);
+
+	return errorResponse("Not implemented yet");
+});
diff --git a/server/api/api/v1/statuses/[id]/unfavourite.ts b/server/api/api/v1/statuses/[id]/unfavourite.ts
index 36de4fe2..66ebe82b 100644
--- a/server/api/api/v1/statuses/[id]/unfavourite.ts
+++ b/server/api/api/v1/statuses/[id]/unfavourite.ts
@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import { client } from "~database/datasource";
 import { deleteLike } from "~database/entities/Like";
 import {
@@ -9,11 +8,9 @@ import {
 	statusAndUserRelations,
 	statusToAPI,
 } from "~database/entities/Status";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
 import type { APIStatus } from "~types/entities/status";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["POST"],
 	ratelimits: {
 		max: 100,
@@ -28,13 +25,10 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Unfavourite a post
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -54,4 +48,4 @@ export default async (
 		favourited: false,
 		favourites_count: status._count.likes - 1,
 	} as APIStatus);
-};
+});
diff --git a/server/api/api/v1/statuses/[id]/unpin.ts b/server/api/api/v1/statuses/[id]/unpin.ts
index af8f4a7a..89ac2da4 100644
--- a/server/api/api/v1/statuses/[id]/unpin.ts
+++ b/server/api/api/v1/statuses/[id]/unpin.ts
@@ -1,13 +1,9 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import { client } from "~database/datasource";
 import { statusAndUserRelations, statusToAPI } from "~database/entities/Status";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["POST"],
 	ratelimits: {
 		max: 100,
@@ -22,13 +18,10 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Unpins a post
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -62,4 +55,4 @@ export default async (
 	if (!status) return errorResponse("Record not found", 404);
 
 	return jsonResponse(statusToAPI(status, user));
-};
+});
diff --git a/server/api/api/v1/statuses/[id]/unreblog.ts b/server/api/api/v1/statuses/[id]/unreblog.ts
index 56a1f82a..07d92b33 100644
--- a/server/api/api/v1/statuses/[id]/unreblog.ts
+++ b/server/api/api/v1/statuses/[id]/unreblog.ts
@@ -1,18 +1,14 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import { client } from "~database/datasource";
 import {
 	isViewableByUser,
 	statusAndUserRelations,
 	statusToAPI,
 } from "~database/entities/Status";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
 import type { APIStatus } from "~types/entities/status";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["POST"],
 	ratelimits: {
 		max: 100,
@@ -27,13 +23,10 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Unreblogs a post
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const id = matchedRoute.params.id;
 
-	const { user } = await getFromRequest(req);
+	const { user } = extraData.auth;
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
@@ -66,4 +59,4 @@ export default async (
 		reblogged: false,
 		reblogs_count: status._count.reblogs - 1,
 	} as APIStatus);
-};
+});
diff --git a/server/api/api/v1/statuses/index.ts b/server/api/api/v1/statuses/index.ts
index 86275366..97eb34e5 100644
--- a/server/api/api/v1/statuses/index.ts
+++ b/server/api/api/v1/statuses/index.ts
@@ -1,12 +1,6 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { applyConfig } from "@api";
-import { getConfig } from "@config";
-import { parseRequest } from "@request";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
 import { sanitizeHtml } from "@sanitization";
-import type { MatchedRoute } from "bun";
 import { parse } from "marked";
 import { client } from "~database/datasource";
 import { getFromToken } from "~database/entities/Application";
@@ -16,10 +10,9 @@ import {
 	statusAndUserRelations,
 	statusToAPI,
 } from "~database/entities/Status";
-import type { AuthData, UserWithRelations } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
+import type { UserWithRelations } from "~database/entities/User";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["POST"],
 	ratelimits: {
 		max: 300,
@@ -34,50 +27,46 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Post new status
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute,
-	authData: AuthData
-): Promise<Response> => {
-	const { user, token } = authData;
+export default apiRoute<{
+	status: string;
+	media_ids?: string[];
+	"poll[options]"?: string[];
+	"poll[expires_in]"?: number;
+	"poll[multiple]"?: boolean;
+	"poll[hide_totals]"?: boolean;
+	in_reply_to_id?: string;
+	quote_id?: string;
+	sensitive?: boolean;
+	spoiler_text?: string;
+	visibility?: "public" | "unlisted" | "private" | "direct";
+	language?: string;
+	scheduled_at?: string;
+	local_only?: boolean;
+	content_type?: string;
+}>(async (req, matchedRoute, extraData) => {
+	const { user, token } = extraData.auth;
 	const application = await getFromToken(token);
 
 	if (!user) return errorResponse("Unauthorized", 401);
 
-	const config = getConfig();
+	const config = await extraData.configManager.getConfig();
 
 	const {
 		status,
 		media_ids,
 		"poll[expires_in]": expires_in,
-		"poll[hide_totals]": hide_totals,
-		"poll[multiple]": multiple,
+		// "poll[hide_totals]": hide_totals,
+		// "poll[multiple]": multiple,
 		"poll[options]": options,
 		in_reply_to_id,
 		quote_id,
-		language,
+		// language,
 		scheduled_at,
 		sensitive,
 		spoiler_text,
 		visibility,
 		content_type,
-	} = await parseRequest<{
-		status: string;
-		media_ids?: string[];
-		"poll[options]"?: string[];
-		"poll[expires_in]"?: number;
-		"poll[multiple]"?: boolean;
-		"poll[hide_totals]"?: boolean;
-		in_reply_to_id?: string;
-		quote_id?: string;
-		sensitive?: boolean;
-		spoiler_text?: string;
-		visibility?: "public" | "unlisted" | "private" | "direct";
-		language?: string;
-		scheduled_at?: string;
-		local_only?: boolean;
-		content_type?: string;
-	}>(req);
+	} = extraData.parsedRequest;
 
 	// Validate status
 	if (!status && !(media_ids && media_ids.length > 0)) {
@@ -153,11 +142,11 @@ export default async (
 	let sanitizedStatus: string;
 
 	if (content_type === "text/markdown") {
-		sanitizedStatus = await sanitizeHtml(parse(status ?? ""));
+		sanitizedStatus = await sanitizeHtml(parse(status ?? "") as any);
 	} else if (content_type === "text/x.misskeymarkdown") {
 		// Parse as MFM
 		// TODO: Parse as MFM
-		sanitizedStatus = await sanitizeHtml(parse(status ?? ""));
+		sanitizedStatus = await sanitizeHtml(parse(status ?? "") as any);
 	} else {
 		sanitizedStatus = await sanitizeHtml(status ?? "");
 	}
@@ -246,7 +235,7 @@ export default async (
 				? {
 						user: replyUser,
 						status: replyStatus,
-				  }
+					}
 				: undefined,
 		quote: quote || undefined,
 	});
@@ -254,4 +243,4 @@ export default async (
 	// TODO: add database jobs to deliver the post
 
 	return jsonResponse(await statusToAPI(newStatus, user));
-};
+});
diff --git a/server/api/api/v1/timelines/home.ts b/server/api/api/v1/timelines/home.ts
index cb1374c4..ce4e96aa 100644
--- a/server/api/api/v1/timelines/home.ts
+++ b/server/api/api/v1/timelines/home.ts
@@ -1,13 +1,9 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { applyConfig } from "@api";
-import { parseRequest } from "@request";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
 import { client } from "~database/datasource";
 import { statusAndUserRelations, statusToAPI } from "~database/entities/Status";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["GET"],
 	ratelimits: {
 		max: 200,
@@ -22,20 +18,15 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Fetch home timeline statuses
  */
-export default async (req: Request): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute<{
+	max_id?: string;
+	since_id?: string;
+	min_id?: string;
+	limit?: number;
+}>(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
-	const {
-		limit = 20,
-		max_id,
-		min_id,
-		since_id,
-	} = await parseRequest<{
-		max_id?: string;
-		since_id?: string;
-		min_id?: string;
-		limit?: number;
-	}>(req);
+	const { limit = 20, max_id, min_id, since_id } = extraData.parsedRequest;
 
 	if (limit < 1 || limit > 40) {
 		return errorResponse("Limit must be between 1 and 40", 400);
@@ -104,4 +95,4 @@ export default async (req: Request): Promise<Response> => {
 			Link: linkHeader.join(", "),
 		}
 	);
-};
+});
diff --git a/server/api/api/v1/timelines/public.ts b/server/api/api/v1/timelines/public.ts
index 6c1e418e..c58cfb15 100644
--- a/server/api/api/v1/timelines/public.ts
+++ b/server/api/api/v1/timelines/public.ts
@@ -1,12 +1,9 @@
-import { applyConfig } from "@api";
-import { parseRequest } from "@request";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
 import { client } from "~database/datasource";
 import { statusAndUserRelations, statusToAPI } from "~database/entities/Status";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["GET"],
 	ratelimits: {
 		max: 200,
@@ -18,8 +15,16 @@ export const meta: APIRouteMeta = applyConfig({
 	},
 });
 
-export default async (req: Request): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute<{
+	local?: boolean;
+	only_media?: boolean;
+	remote?: boolean;
+	max_id?: string;
+	since_id?: string;
+	min_id?: string;
+	limit?: number;
+}>(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 	const {
 		local,
 		limit = 20,
@@ -28,15 +33,7 @@ export default async (req: Request): Promise<Response> => {
 		// only_media,
 		remote,
 		since_id,
-	} = await parseRequest<{
-		local?: boolean;
-		only_media?: boolean;
-		remote?: boolean;
-		max_id?: string;
-		since_id?: string;
-		min_id?: string;
-		limit?: number;
-	}>(req);
+	} = extraData.parsedRequest;
 
 	if (limit < 1 || limit > 40) {
 		return errorResponse("Limit must be between 1 and 40", 400);
@@ -56,10 +53,10 @@ export default async (req: Request): Promise<Response> => {
 			instanceId: remote
 				? {
 						not: null,
-				  }
+					}
 				: local
-				  ? null
-				  : undefined,
+					? null
+					: undefined,
 		},
 		include: statusAndUserRelations,
 		take: limit,
@@ -87,4 +84,4 @@ export default async (req: Request): Promise<Response> => {
 			Link: linkHeader.join(", "),
 		}
 	);
-};
+});
diff --git a/server/api/api/v2/media/index.ts b/server/api/api/v2/media/index.ts
index 51bc2997..2593ae05 100644
--- a/server/api/api/v2/media/index.ts
+++ b/server/api/api/v2/media/index.ts
@@ -1,15 +1,15 @@
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
 import { client } from "~database/datasource";
 import { encode } from "blurhash";
-import { getFromRequest } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
 import sharp from "sharp";
-import { uploadFile } from "~classes/media";
-import { getConfig } from "@config";
 import { attachmentToAPI, getUrl } from "~database/entities/Attachment";
+import type { MediaBackend } from "media-manager";
+import { MediaBackendType } from "media-manager";
+import { LocalMediaBackend } from "~packages/media-manager/backends/local";
+import { S3MediaBackend } from "~packages/media-manager/backends/s3";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["POST"],
 	ratelimits: {
 		max: 10,
@@ -25,27 +25,26 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * Upload new media
  */
-export default async (req: Request): Promise<Response> => {
-	const { user } = await getFromRequest(req);
+export default apiRoute<{
+	file: File;
+	thumbnail: File;
+	description: string;
+	// TODO: Implement focus storage
+	focus: string;
+}>(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
 
 	if (!user) {
 		return errorResponse("Unauthorized", 401);
 	}
 
-	const form = await req.formData();
-
-	const file = form.get("file") as unknown as File | undefined;
-	const thumbnail = form.get("thumbnail");
-	const description = form.get("description") as string | undefined;
-
-	// Floating point numbers from -1.0 to 1.0, comma delimited
-	// const focus = form.get("focus");
+	const { file, thumbnail, description } = extraData.parsedRequest;
 
 	if (!file) {
 		return errorResponse("No file provided", 400);
 	}
 
-	const config = getConfig();
+	const config = await extraData.configManager.getConfig();
 
 	if (file.size > config.validation.max_media_size) {
 		return errorResponse(
@@ -86,23 +85,37 @@ export default async (req: Request): Promise<Response> => {
 				metadata?.height ?? 0,
 				4,
 				4
-		  )
+			)
 		: null;
 
 	let url = "";
 
-	if (isImage) {
-		const hash = await uploadFile(file, config);
+	let mediaManager: MediaBackend;
 
-		url = hash ? getUrl(hash, config) : "";
+	switch (config.media.backend as MediaBackendType) {
+		case MediaBackendType.LOCAL:
+			mediaManager = new LocalMediaBackend(config);
+			break;
+		case MediaBackendType.S3:
+			mediaManager = new S3MediaBackend(config);
+			break;
+		default:
+			// TODO: Replace with logger
+			throw new Error("Invalid media backend");
+	}
+
+	if (isImage) {
+		const { uploadedFile } = await mediaManager.addFile(file);
+
+		url = getUrl(uploadedFile.name, config);
 	}
 
 	let thumbnailUrl = "";
 
 	if (thumbnail) {
-		const hash = await uploadFile(thumbnail as unknown as File, config);
+		const { uploadedFile } = await mediaManager.addFile(thumbnail);
 
-		thumbnailUrl = hash ? getUrl(hash, config) : "";
+		thumbnailUrl = getUrl(uploadedFile.name, config);
 	}
 
 	const newAttachment = await client.attachment.create({
@@ -132,4 +145,4 @@ export default async (req: Request): Promise<Response> => {
 			202
 		);
 	}
-};
+});
diff --git a/server/api/api/v2/search/index.ts b/server/api/api/v2/search/index.ts
new file mode 100644
index 00000000..c327dedb
--- /dev/null
+++ b/server/api/api/v2/search/index.ts
@@ -0,0 +1,139 @@
+import { apiRoute, applyConfig } from "@api";
+import { MeiliIndexType, meilisearch } from "@meilisearch";
+import { errorResponse, jsonResponse } from "@response";
+import { client } from "~database/datasource";
+import { statusAndUserRelations, statusToAPI } from "~database/entities/Status";
+import { userRelations, userToAPI } from "~database/entities/User";
+
+export const meta = applyConfig({
+	allowedMethods: ["GET"],
+	ratelimits: {
+		max: 10,
+		duration: 60,
+	},
+	route: "/api/v2/search",
+	auth: {
+		required: false,
+		oauthPermissions: ["read:search"],
+	},
+});
+
+/**
+ * Upload new media
+ */
+export default apiRoute<{
+	q?: string;
+	type?: string;
+	resolve?: boolean;
+	following?: boolean;
+	account_id?: string;
+	max_id?: string;
+	min_id?: string;
+	limit?: number;
+	offset?: number;
+}>(async (req, matchedRoute, extraData) => {
+	const { user } = extraData.auth;
+
+	const {
+		q,
+		type,
+		resolve,
+		following,
+		account_id,
+		// max_id,
+		// min_id,
+		limit = 20,
+		offset,
+	} = extraData.parsedRequest;
+
+	const config = await extraData.configManager.getConfig();
+
+	if (!config.meilisearch.enabled) {
+		return errorResponse("Meilisearch is not enabled", 501);
+	}
+
+	if (!user && (resolve || offset)) {
+		return errorResponse(
+			"Cannot use resolve or offset without being authenticated",
+			401
+		);
+	}
+
+	if (limit < 1 || limit > 40) {
+		return errorResponse("Limit must be between 1 and 40", 400);
+	}
+
+	let accountResults: { id: string }[] = [];
+	let statusResults: { id: string }[] = [];
+
+	if (!type || type === "accounts") {
+		accountResults = (
+			await meilisearch.index(MeiliIndexType.Accounts).search<{
+				id: string;
+			}>(q, {
+				limit: Number(limit) || 10,
+				offset: Number(offset) || 0,
+				sort: ["createdAt:desc"],
+			})
+		).hits;
+	}
+
+	if (!type || type === "statuses") {
+		statusResults = (
+			await meilisearch.index(MeiliIndexType.Statuses).search<{
+				id: string;
+			}>(q, {
+				limit: Number(limit) || 10,
+				offset: Number(offset) || 0,
+				sort: ["createdAt:desc"],
+			})
+		).hits;
+	}
+
+	const accounts = await client.user.findMany({
+		where: {
+			id: {
+				in: accountResults.map(hit => hit.id),
+			},
+			relationshipSubjects: {
+				some: {
+					subjectId: user?.id,
+					following: following ? true : undefined,
+				},
+			},
+		},
+		orderBy: {
+			createdAt: "desc",
+		},
+		include: userRelations,
+	});
+
+	const statuses = await client.status.findMany({
+		where: {
+			id: {
+				in: statusResults.map(hit => hit.id),
+			},
+			author: {
+				relationshipSubjects: {
+					some: {
+						subjectId: user?.id,
+						following: following ? true : undefined,
+					},
+				},
+			},
+			authorId: account_id ? account_id : undefined,
+		},
+		orderBy: {
+			createdAt: "desc",
+		},
+		include: statusAndUserRelations,
+	});
+
+	return jsonResponse({
+		accounts: accounts.map(account => userToAPI(account)),
+		statuses: await Promise.all(
+			statuses.map(status => statusToAPI(status))
+		),
+		hashtags: [],
+	});
+});
diff --git a/server/api/auth/login/index.ts b/server/api/auth/login/index.ts
index 8a3b9b24..7b9094b6 100644
--- a/server/api/auth/login/index.ts
+++ b/server/api/auth/login/index.ts
@@ -1,13 +1,10 @@
-import { applyConfig } from "@api";
-import { errorResponse } from "@response";
-import type { MatchedRoute } from "bun";
+import { apiRoute, applyConfig } from "@api";
 import { randomBytes } from "crypto";
 import { client } from "~database/datasource";
 import { TokenType } from "~database/entities/Token";
 import { userRelations } from "~database/entities/User";
-import type { APIRouteMeta } from "~types/api";
 
-export const meta: APIRouteMeta = applyConfig({
+export const meta = applyConfig({
 	allowedMethods: ["POST"],
 	ratelimits: {
 		max: 4,
@@ -22,10 +19,10 @@ export const meta: APIRouteMeta = applyConfig({
 /**
  * OAuth Code flow
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute<{
+	email: string;
+	password: string;
+}>(async (req, matchedRoute, extraData) => {
 	const scopes = (matchedRoute.query.scope || "")
 		.replaceAll("+", " ")
 		.split(" ");
@@ -33,16 +30,23 @@ export default async (
 	const response_type = matchedRoute.query.response_type;
 	const client_id = matchedRoute.query.client_id;
 
-	const formData = await req.formData();
+	const { email, password } = extraData.parsedRequest;
 
-	const email = formData.get("email")?.toString() || null;
-	const password = formData.get("password")?.toString() || null;
+	const redirectToLogin = (error: string) =>
+		Response.redirect(
+			`/oauth/authorize?` +
+				new URLSearchParams({
+					...matchedRoute.query,
+					error: encodeURIComponent(error),
+				}).toString(),
+			302
+		);
 
 	if (response_type !== "code")
-		return errorResponse("Invalid response type (try 'code')", 400);
+		return redirectToLogin("Invalid response_type");
 
 	if (!email || !password)
-		return errorResponse("Missing username or password", 400);
+		return redirectToLogin("Invalid username or password");
 
 	// Get user
 	const user = await client.user.findFirst({
@@ -53,7 +57,7 @@ export default async (
 	});
 
 	if (!user || !(await Bun.password.verify(password, user.password || "")))
-		return errorResponse("Invalid username or password", 401);
+		return redirectToLogin("Invalid username or password");
 
 	// Get application
 	const application = await client.application.findFirst({
@@ -62,7 +66,7 @@ export default async (
 		},
 	});
 
-	if (!application) return errorResponse("Invalid client_id", 404);
+	if (!application) return redirectToLogin("Invalid client_id");
 
 	const code = randomBytes(32).toString("hex");
 
@@ -87,4 +91,4 @@ export default async (
 
 	// Redirect back to application
 	return Response.redirect(`${redirect_uri}?code=${code}`, 302);
-};
+});
diff --git a/server/api/media/[id]/index.ts b/server/api/media/[id]/index.ts
index cd8ebfae..4ee0589a 100644
--- a/server/api/media/[id]/index.ts
+++ b/server/api/media/[id]/index.ts
@@ -1,6 +1,5 @@
 import { errorResponse } from "@response";
-import { applyConfig } from "@api";
-import type { MatchedRoute } from "bun";
+import { apiRoute, applyConfig } from "@api";
 
 export const meta = applyConfig({
 	allowedMethods: ["GET"],
@@ -14,10 +13,7 @@ export const meta = applyConfig({
 	},
 });
 
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute) => {
 	// TODO: Add checks for disabled or not email verified accounts
 
 	const id = matchedRoute.params.id;
@@ -46,4 +42,4 @@ export default async (
 			"Content-Range": `bytes ${start}-${end}/${file.size}`,
 		},
 	});
-};
+});
diff --git a/server/api/nodeinfo/2.0/index.ts b/server/api/nodeinfo/2.0/index.ts
index 8d3c0cef..99288f60 100644
--- a/server/api/nodeinfo/2.0/index.ts
+++ b/server/api/nodeinfo/2.0/index.ts
@@ -1,4 +1,4 @@
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { jsonResponse } from "@response";
 
 export const meta = applyConfig({
@@ -16,8 +16,7 @@ export const meta = applyConfig({
 /**
  * ActivityPub nodeinfo 2.0 endpoint
  */
-// eslint-disable-next-line @typescript-eslint/require-await
-export default async (): Promise<Response> => {
+export default apiRoute(() => {
 	// TODO: Implement this
 	return jsonResponse({
 		version: "2.0",
@@ -31,4 +30,4 @@ export default async (): Promise<Response> => {
 		openRegistrations: false,
 		metadata: {},
 	});
-};
+});
diff --git a/server/api/oauth/authorize-external/index.ts b/server/api/oauth/authorize-external/index.ts
new file mode 100644
index 00000000..688f7a6a
--- /dev/null
+++ b/server/api/oauth/authorize-external/index.ts
@@ -0,0 +1,95 @@
+import { apiRoute, applyConfig } from "@api";
+import { oauthRedirectUri } from "@constants";
+import {
+	calculatePKCECodeChallenge,
+	discoveryRequest,
+	generateRandomCodeVerifier,
+	processDiscoveryResponse,
+} from "oauth4webapi";
+import { client } from "~database/datasource";
+
+export const meta = applyConfig({
+	allowedMethods: ["GET"],
+	auth: {
+		required: false,
+	},
+	ratelimits: {
+		duration: 60,
+		max: 20,
+	},
+	route: "/oauth/authorize-external",
+});
+
+/**
+ * Redirects the user to the external OAuth provider
+ */
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const redirectToLogin = (error: string) =>
+		Response.redirect(
+			`/oauth/authorize?` +
+				new URLSearchParams({
+					...matchedRoute.query,
+					error: encodeURIComponent(error),
+				}).toString(),
+			302
+		);
+
+	const issuerId = matchedRoute.query.issuer;
+
+	// This is the Lysand client's client_id, not the external OAuth provider's client_id
+	const clientId = matchedRoute.query.clientId;
+
+	if (!clientId || clientId === "undefined") {
+		return redirectToLogin("Missing client_id");
+	}
+
+	const config = await extraData.configManager.getConfig();
+
+	const issuer = config.oidc.providers.find(
+		provider => provider.id === issuerId
+	);
+
+	if (!issuer) {
+		return redirectToLogin("Invalid issuer");
+	}
+
+	const issuerUrl = new URL(issuer.url);
+
+	const authServer = await discoveryRequest(issuerUrl, {
+		algorithm: "oidc",
+	}).then(res => processDiscoveryResponse(issuerUrl, res));
+
+	const codeVerifier = generateRandomCodeVerifier();
+
+	// Store into database
+
+	const newFlow = await client.openIdLoginFlow.create({
+		data: {
+			codeVerifier,
+			application: {
+				connect: {
+					client_id: clientId,
+				},
+			},
+			issuerId,
+		},
+	});
+
+	const codeChallenge = await calculatePKCECodeChallenge(codeVerifier);
+
+	return Response.redirect(
+		authServer.authorization_endpoint +
+			"?" +
+			new URLSearchParams({
+				client_id: issuer.client_id,
+				redirect_uri:
+					oauthRedirectUri(issuerId) + `?flow=${newFlow.id}`,
+				response_type: "code",
+				scope: "openid profile email",
+				// PKCE
+				code_challenge_method: "S256",
+				code_challenge: codeChallenge,
+			}).toString(),
+		302
+	);
+});
diff --git a/server/api/oauth/authorize/index.ts b/server/api/oauth/authorize/index.ts
deleted file mode 100644
index 219437d6..00000000
--- a/server/api/oauth/authorize/index.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { applyConfig } from "@api";
-import type { MatchedRoute } from "bun";
-
-export const meta = applyConfig({
-	allowedMethods: ["GET"],
-	auth: {
-		required: false,
-	},
-	ratelimits: {
-		duration: 60,
-		max: 20,
-	},
-	route: "/oauth/authorize",
-});
-
-/**
- * Returns an HTML login form
- */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
-	const html = Bun.file("./pages/login.html");
-	const css = Bun.file("./pages/uno.css");
-	return new Response(
-		(await html.text())
-			.replace(
-				"{{URL}}",
-				`/auth/login?redirect_uri=${matchedRoute.query.redirect_uri}&response_type=${matchedRoute.query.response_type}&client_id=${matchedRoute.query.client_id}&scope=${matchedRoute.query.scope}`
-			)
-			.replace("{{STYLES}}", `<style>${await css.text()}</style>`),
-		{
-			headers: {
-				"Content-Type": "text/html",
-			},
-		}
-	);
-};
diff --git a/server/api/oauth/callback/[issuer]/index.ts b/server/api/oauth/callback/[issuer]/index.ts
new file mode 100644
index 00000000..15d905eb
--- /dev/null
+++ b/server/api/oauth/callback/[issuer]/index.ts
@@ -0,0 +1,190 @@
+import { apiRoute, applyConfig } from "@api";
+import { oauthRedirectUri } from "@constants";
+import { randomBytes } from "crypto";
+import {
+	authorizationCodeGrantRequest,
+	discoveryRequest,
+	expectNoState,
+	isOAuth2Error,
+	processDiscoveryResponse,
+	validateAuthResponse,
+	userInfoRequest,
+	processAuthorizationCodeOpenIDResponse,
+	processUserInfoResponse,
+	getValidatedIdTokenClaims,
+} from "oauth4webapi";
+import { client } from "~database/datasource";
+import { TokenType } from "~database/entities/Token";
+
+export const meta = applyConfig({
+	allowedMethods: ["GET"],
+	auth: {
+		required: false,
+	},
+	ratelimits: {
+		duration: 60,
+		max: 20,
+	},
+	route: "/oauth/callback/:issuer",
+});
+
+/**
+ * Redirects the user to the external OAuth provider
+ */
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const redirectToLogin = (error: string) =>
+		Response.redirect(
+			`/oauth/authorize?` +
+				new URLSearchParams({
+					client_id: matchedRoute.query.clientId,
+					error: encodeURIComponent(error),
+				}).toString(),
+			302
+		);
+
+	const currentUrl = new URL(req.url);
+
+	// Remove state query parameter from URL
+	currentUrl.searchParams.delete("state");
+	const issuerParam = matchedRoute.params.issuer;
+	const flow = await client.openIdLoginFlow.findFirst({
+		where: {
+			id: matchedRoute.query.flow,
+		},
+		include: {
+			application: true,
+		},
+	});
+
+	if (!flow) {
+		return redirectToLogin("Invalid flow");
+	}
+
+	const config = await extraData.configManager.getConfig();
+
+	const issuer = config.oidc.providers.find(
+		provider => provider.id === issuerParam
+	);
+
+	if (!issuer) {
+		return redirectToLogin("Invalid issuer");
+	}
+
+	const issuerUrl = new URL(issuer.url);
+
+	const authServer = await discoveryRequest(issuerUrl, {
+		algorithm: "oidc",
+	}).then(res => processDiscoveryResponse(issuerUrl, res));
+
+	const parameters = validateAuthResponse(
+		authServer,
+		{
+			client_id: issuer.client_id,
+			client_secret: issuer.client_secret,
+		},
+		currentUrl,
+		// Whether to expect state or not
+		expectNoState
+	);
+
+	if (isOAuth2Error(parameters)) {
+		return redirectToLogin(
+			parameters.error_description || parameters.error
+		);
+	}
+
+	const response = await authorizationCodeGrantRequest(
+		authServer,
+		{
+			client_id: issuer.client_id,
+			client_secret: issuer.client_secret,
+		},
+		parameters,
+		oauthRedirectUri(issuerParam) + `?flow=${flow.id}`,
+		flow.codeVerifier
+	);
+
+	const result = await processAuthorizationCodeOpenIDResponse(
+		authServer,
+		{
+			client_id: issuer.client_id,
+			client_secret: issuer.client_secret,
+		},
+		response
+	);
+
+	if (isOAuth2Error(result)) {
+		return redirectToLogin(result.error_description || result.error);
+	}
+
+	const { access_token } = result;
+
+	const claims = getValidatedIdTokenClaims(result);
+	const { sub } = claims;
+
+	// Validate `sub`
+	// Later, we'll use this to automatically set the user's data
+	await userInfoRequest(
+		authServer,
+		{
+			client_id: issuer.client_id,
+			client_secret: issuer.client_secret,
+		},
+		access_token
+	).then(res =>
+		processUserInfoResponse(
+			authServer,
+			{
+				client_id: issuer.client_id,
+				client_secret: issuer.client_secret,
+			},
+			sub,
+			res
+		)
+	);
+
+	const user = await client.user.findFirst({
+		where: {
+			linkedOpenIdAccounts: {
+				some: {
+					serverId: sub,
+					issuerId: issuer.id,
+				},
+			},
+		},
+	});
+
+	if (!user) {
+		return redirectToLogin("No user found with that account");
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+	if (!flow.application) return redirectToLogin("Invalid client_id");
+
+	const code = randomBytes(32).toString("hex");
+
+	await client.application.update({
+		where: { id: flow.application.id },
+		data: {
+			tokens: {
+				create: {
+					access_token: randomBytes(64).toString("base64url"),
+					code: code,
+					scope: flow.application.scopes,
+					token_type: TokenType.BEARER,
+					user: {
+						connect: {
+							id: user.id,
+						},
+					},
+				},
+			},
+		},
+	});
+
+	// Redirect back to application
+	return Response.redirect(
+		`${flow.application.redirect_uris}?code=${code}`,
+		302
+	);
+});
diff --git a/server/api/oauth/providers/index.ts b/server/api/oauth/providers/index.ts
new file mode 100644
index 00000000..ad0d9769
--- /dev/null
+++ b/server/api/oauth/providers/index.ts
@@ -0,0 +1,29 @@
+import { apiRoute, applyConfig } from "@api";
+import { jsonResponse } from "@response";
+
+export const meta = applyConfig({
+	allowedMethods: ["GET"],
+	auth: {
+		required: false,
+	},
+	ratelimits: {
+		duration: 60,
+		max: 10,
+	},
+	route: "/oauth/providers",
+});
+
+/**
+ * Lists available OAuth providers
+ */
+export default apiRoute(async (req, matchedRoute, extraData) => {
+	const config = await extraData.configManager.getConfig();
+
+	return jsonResponse(
+		config.oidc.providers.map(p => ({
+			name: p.name,
+			icon: p.icon,
+			id: p.id,
+		}))
+	);
+});
diff --git a/server/api/oauth/token/index.ts b/server/api/oauth/token/index.ts
index 70a68db8..f75f2209 100644
--- a/server/api/oauth/token/index.ts
+++ b/server/api/oauth/token/index.ts
@@ -1,5 +1,4 @@
-import { applyConfig } from "@api";
-import { parseRequest } from "@request";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
 import { client } from "~database/datasource";
 
@@ -18,16 +17,16 @@ export const meta = applyConfig({
 /**
  * Allows getting token from OAuth code
  */
-export default async (req: Request): Promise<Response> => {
+export default apiRoute<{
+	grant_type: string;
+	code: string;
+	redirect_uri: string;
+	client_id: string;
+	client_secret: string;
+	scope: string;
+}>(async (req, matchedRoute, extraData) => {
 	const { grant_type, code, redirect_uri, client_id, client_secret, scope } =
-		await parseRequest<{
-			grant_type: string;
-			code: string;
-			redirect_uri: string;
-			client_id: string;
-			client_secret: string;
-			scope: string;
-		}>(req);
+		extraData.parsedRequest;
 
 	if (grant_type !== "authorization_code")
 		return errorResponse(
@@ -61,4 +60,4 @@ export default async (req: Request): Promise<Response> => {
 		scope: token.scope,
 		created_at: token.created_at,
 	});
-};
+});
diff --git a/server/api/object/[uuid]/index.ts b/server/api/object/[uuid]/index.ts
index 4d91f5b9..3803234b 100644
--- a/server/api/object/[uuid]/index.ts
+++ b/server/api/object/[uuid]/index.ts
@@ -1,8 +1,5 @@
-/* eslint-disable @typescript-eslint/require-await */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import { jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 
 export const meta = applyConfig({
 	allowedMethods: ["GET"],
@@ -16,12 +13,6 @@ export const meta = applyConfig({
 	route: "/object/:id",
 });
 
-/**
- * Fetch a user
- */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(() => {
 	return jsonResponse({});
-};
+});
diff --git a/server/api/routes.type.ts b/server/api/routes.type.ts
new file mode 100644
index 00000000..d3cea716
--- /dev/null
+++ b/server/api/routes.type.ts
@@ -0,0 +1,13 @@
+import type { MatchedRoute } from "bun";
+import type { ConfigManager } from "config-manager";
+import type { AuthData } from "~database/entities/User";
+
+export type RouteHandler<T> = (
+	req: Request,
+	matchedRoute: MatchedRoute,
+	extraData: {
+		auth: AuthData;
+		parsedRequest: Partial<T>;
+		configManager: ConfigManager;
+	}
+) => Response | Promise<Response>;
diff --git a/server/api/users/[uuid]/inbox/index.ts b/server/api/users/[uuid]/inbox/index.ts
index f749908d..f1547cc0 100644
--- a/server/api/users/[uuid]/inbox/index.ts
+++ b/server/api/users/[uuid]/inbox/index.ts
@@ -1,10 +1,7 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { applyConfig } from "@api";
-import { getConfig } from "@config";
+// TODO: Refactor into smaller packages
+import { apiRoute, applyConfig } from "@api";
 import { getBestContentType } from "@content_types";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import { client } from "~database/datasource";
 import { parseEmojis } from "~database/entities/Emoji";
 import { createLike, deleteLike } from "~database/entities/Like";
@@ -39,13 +36,10 @@ export const meta = applyConfig({
 /**
  * ActivityPub user inbox endpoint
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const username = matchedRoute.params.username;
 
-	const config = getConfig();
+	const config = await extraData.configManager.getConfig();
 
 	try {
 		if (
@@ -313,7 +307,7 @@ export default async (
 			}
 
 			// Create new reblog
-			const newReblog = await client.status.create({
+			await client.status.create({
 				data: {
 					authorId: author.id,
 					reblogId: rebloggedStatus.id,
@@ -405,4 +399,4 @@ export default async (
 	}
 
 	return jsonResponse({});
-};
+});
diff --git a/server/api/users/[uuid]/index.ts b/server/api/users/[uuid]/index.ts
index d56dc905..763caf08 100644
--- a/server/api/users/[uuid]/index.ts
+++ b/server/api/users/[uuid]/index.ts
@@ -1,9 +1,5 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { applyConfig } from "@api";
-import { getConfig } from "@config";
+import { apiRoute, applyConfig } from "@api";
 import { errorResponse, jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
 import { client } from "~database/datasource";
 import { userRelations, userToLysand } from "~database/entities/User";
 
@@ -22,14 +18,9 @@ export const meta = applyConfig({
 /**
  * ActivityPub user inbox endpoint
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute) => {
 	const uuid = matchedRoute.params.uuid;
 
-	const config = getConfig();
-
 	const user = await client.user.findUnique({
 		where: {
 			id: uuid,
@@ -42,4 +33,4 @@ export default async (
 	}
 
 	return jsonResponse(userToLysand(user));
-};
+});
diff --git a/server/api/users/[uuid]/outbox/index.ts b/server/api/users/[uuid]/outbox/index.ts
index b6b47750..90add2c7 100644
--- a/server/api/users/[uuid]/outbox/index.ts
+++ b/server/api/users/[uuid]/outbox/index.ts
@@ -1,7 +1,5 @@
 import { jsonResponse } from "@response";
-import type { MatchedRoute } from "bun";
-import { getConfig, getHost } from "@config";
-import { applyConfig } from "@api";
+import { apiRoute, applyConfig } from "@api";
 import {
 	statusAndUserRelations,
 	statusToLysand,
@@ -23,13 +21,11 @@ export const meta = applyConfig({
 /**
  * ActivityPub user outbox endpoint
  */
-export default async (
-	req: Request,
-	matchedRoute: MatchedRoute
-): Promise<Response> => {
+export default apiRoute(async (req, matchedRoute, extraData) => {
 	const uuid = matchedRoute.params.uuid;
 	const pageNumber = Number(matchedRoute.query.page) || 1;
-	const config = getConfig();
+	const config = await extraData.configManager.getConfig();
+	const host = new URL(config.http.base_url).hostname;
 
 	const statuses = await client.status.findMany({
 		where: {
@@ -53,19 +49,19 @@ export default async (
 	});
 
 	return jsonResponse({
-		first: `${getHost()}/users/${uuid}/outbox?page=1`,
-		last: `${getHost()}/users/${uuid}/outbox?page=1`,
+		first: `${host}/users/${uuid}/outbox?page=1`,
+		last: `${host}/users/${uuid}/outbox?page=1`,
 		total_items: totalStatuses,
 		// Server actor
 		author: `${config.http.base_url}/users/actor`,
 		next:
 			statuses.length === 20
-				? `${getHost()}/users/${uuid}/outbox?page=${pageNumber + 1}`
+				? `${host}/users/${uuid}/outbox?page=${pageNumber + 1}`
 				: undefined,
 		prev:
 			pageNumber > 1
-				? `${getHost()}/users/${uuid}/outbox?page=${pageNumber - 1}`
+				? `${host}/users/${uuid}/outbox?page=${pageNumber - 1}`
 				: undefined,
 		items: statuses.map(s => statusToLysand(s)),
 	});
-};
+});
diff --git a/tests/actor.test.ts b/tests/actor.test.ts
deleted file mode 100644
index fab17ac7..00000000
--- a/tests/actor.test.ts
+++ /dev/null
@@ -1 +0,0 @@
-// Empty file
diff --git a/tests/api.test.ts b/tests/api.test.ts
index 1570393d..3416c9b3 100644
--- a/tests/api.test.ts
+++ b/tests/api.test.ts
@@ -1,8 +1,6 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { getConfig } from "@config";
 import type { Token } from "@prisma/client";
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { ConfigManager } from "config-manager";
 import { client } from "~database/datasource";
 import { TokenType } from "~database/entities/Token";
 import {
@@ -11,8 +9,10 @@ import {
 } from "~database/entities/User";
 import type { APIEmoji } from "~types/entities/emoji";
 import type { APIInstance } from "~types/entities/instance";
+import { sendTestRequest, wrapRelativeUrl } from "./utils";
 
-const config = getConfig();
+const config = await new ConfigManager({}).getConfig();
+const base_url = config.http.base_url;
 
 let token: Token;
 let user: UserWithRelations;
@@ -61,18 +61,26 @@ describe("API Tests", () => {
 				},
 			},
 		});
+
+		await client.application.deleteMany({
+			where: {
+				client_id: "test",
+			},
+		});
 	});
 
 	describe("GET /api/v1/instance", () => {
 		test("should return an APIInstance object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/instance`,
-				{
-					method: "GET",
-					headers: {
-						"Content-Type": "application/json",
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(`${base_url}/api/v1/instance`, base_url),
+					{
+						method: "GET",
+						headers: {
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -111,15 +119,21 @@ describe("API Tests", () => {
 				},
 			});
 		});
+
 		test("should return an array of at least one custom emoji", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/custom_emojis`,
-				{
-					method: "GET",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`${base_url}/api/v1/custom_emojis`,
+						base_url
+					),
+					{
+						method: "GET",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -130,9 +144,10 @@ describe("API Tests", () => {
 			const emojis = (await response.json()) as APIEmoji[];
 
 			expect(emojis.length).toBeGreaterThan(0);
-			expect(emojis[0].shortcode).toBe("test");
-			expect(emojis[0].url).toBe("https://example.com/test.png");
+			expect(emojis[0].shortcode).toBeString();
+			expect(emojis[0].url).toBeString();
 		});
+
 		afterAll(async () => {
 			await client.emoji.deleteMany({
 				where: {
diff --git a/tests/api/accounts.test.ts b/tests/api/accounts.test.ts
index 0c21f46c..201d1066 100644
--- a/tests/api/accounts.test.ts
+++ b/tests/api/accounts.test.ts
@@ -1,6 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { getConfig } from "@config";
 import type { Token } from "@prisma/client";
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { client } from "~database/datasource";
@@ -12,84 +9,95 @@ import {
 import type { APIAccount } from "~types/entities/account";
 import type { APIRelationship } from "~types/entities/relationship";
 import type { APIStatus } from "~types/entities/status";
+import { ConfigManager } from "config-manager";
+import { sendTestRequest, wrapRelativeUrl } from "~tests/utils";
 
-const config = getConfig();
+const config = await new ConfigManager({}).getConfig();
+const base_url = config.http.base_url;
 
 let token: Token;
 let user: UserWithRelations;
 let user2: UserWithRelations;
 
+beforeAll(async () => {
+	await client.user.deleteMany({
+		where: {
+			username: {
+				in: ["test", "test2"],
+			},
+		},
+	});
+
+	user = await createNewLocalUser({
+		email: "test@test.com",
+		username: "test",
+		password: "test",
+		display_name: "",
+	});
+
+	user2 = await createNewLocalUser({
+		email: "test2@test.com",
+		username: "test2",
+		password: "test2",
+		display_name: "",
+	});
+
+	token = await client.token.create({
+		data: {
+			access_token: "test",
+			application: {
+				create: {
+					client_id: "test",
+					name: "Test Application",
+					redirect_uris: "https://example.com",
+					scopes: "read write",
+					secret: "test",
+					website: "https://example.com",
+					vapid_key: null,
+				},
+			},
+			code: "test",
+			scope: "read write",
+			token_type: TokenType.BEARER,
+			user: {
+				connect: {
+					id: user.id,
+				},
+			},
+		},
+	});
+});
+
+afterAll(async () => {
+	await client.user.deleteMany({
+		where: {
+			username: {
+				in: ["test", "test2"],
+			},
+		},
+	});
+
+	await client.application.deleteMany({
+		where: {
+			client_id: "test",
+		},
+	});
+});
+
 describe("API Tests", () => {
-	beforeAll(async () => {
-		await client.user.deleteMany({
-			where: {
-				username: {
-					in: ["test", "test2"],
-				},
-			},
-		});
-
-		user = await createNewLocalUser({
-			email: "test@test.com",
-			username: "test",
-			password: "test",
-			display_name: "",
-		});
-
-		user2 = await createNewLocalUser({
-			email: "test2@test.com",
-			username: "test2",
-			password: "test2",
-			display_name: "",
-		});
-
-		token = await client.token.create({
-			data: {
-				access_token: "test",
-				application: {
-					create: {
-						client_id: "test",
-						name: "Test Application",
-						redirect_uris: "https://example.com",
-						scopes: "read write",
-						secret: "test",
-						website: "https://example.com",
-						vapid_key: null,
-					},
-				},
-				code: "test",
-				scope: "read write",
-				token_type: TokenType.BEARER,
-				user: {
-					connect: {
-						id: user.id,
-					},
-				},
-			},
-		});
-	});
-
-	afterAll(async () => {
-		await client.user.deleteMany({
-			where: {
-				username: {
-					in: ["test", "test2"],
-				},
-			},
-		});
-	});
-
 	describe("POST /api/v1/accounts/:id", () => {
 		test("should return a 404 error when trying to fetch a non-existent user", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/999999`,
-				{
-					method: "GET",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl("/api/v1/accounts/999999", base_url),
+					{
+						method: "GET",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(404);
@@ -101,18 +109,23 @@ describe("API Tests", () => {
 
 	describe("PATCH /api/v1/accounts/update_credentials", () => {
 		test("should update the authenticated user's display name", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/update_credentials`,
-				{
-					method: "PATCH",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({
-						display_name: "New Display Name",
-					}),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						"/api/v1/accounts/update_credentials",
+						base_url
+					),
+					{
+						method: "PATCH",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({
+							display_name: "New Display Name",
+						}),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -128,15 +141,20 @@ describe("API Tests", () => {
 
 	describe("GET /api/v1/accounts/verify_credentials", () => {
 		test("should return the authenticated user's account information", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/verify_credentials`,
-				{
-					method: "GET",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						"/api/v1/accounts/verify_credentials",
+						base_url
+					),
+					{
+						method: "GET",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -173,15 +191,20 @@ describe("API Tests", () => {
 
 	describe("GET /api/v1/accounts/:id/statuses", () => {
 		test("should return the statuses of the specified user", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user.id}/statuses`,
-				{
-					method: "GET",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user.id}/statuses`,
+						base_url
+					),
+					{
+						method: "GET",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -197,16 +220,21 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/accounts/:id/follow", () => {
 		test("should follow the specified user and return an APIRelationship object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user2.id}/follow`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({}),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user2.id}/follow`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({}),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -223,16 +251,21 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/accounts/:id/unfollow", () => {
 		test("should unfollow the specified user and return an APIRelationship object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user2.id}/unfollow`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({}),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user2.id}/unfollow`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({}),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -249,16 +282,21 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/accounts/:id/remove_from_followers", () => {
 		test("should remove the specified user from the authenticated user's followers and return an APIRelationship object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user2.id}/remove_from_followers`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({}),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user2.id}/remove_from_followers`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({}),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -275,16 +313,21 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/accounts/:id/block", () => {
 		test("should block the specified user and return an APIRelationship object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user2.id}/block`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({}),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user2.id}/block`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({}),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -301,14 +344,13 @@ describe("API Tests", () => {
 
 	describe("GET /api/v1/blocks", () => {
 		test("should return an array of APIAccount objects for the user's blocked accounts", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/blocks`,
-				{
+			const response = await sendTestRequest(
+				new Request(wrapRelativeUrl("/api/v1/blocks", base_url), {
 					method: "GET",
 					headers: {
 						Authorization: `Bearer ${token.access_token}`,
 					},
-				}
+				})
 			);
 
 			expect(response.status).toBe(200);
@@ -325,16 +367,21 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/accounts/:id/unblock", () => {
 		test("should unblock the specified user and return an APIRelationship object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user2.id}/unblock`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({}),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user2.id}/unblock`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({}),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -351,16 +398,21 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/accounts/:id/mute with notifications parameter", () => {
 		test("should mute the specified user and return an APIRelationship object with notifications set to false", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user2.id}/mute`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({ notifications: true }),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user2.id}/mute`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({ notifications: true }),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -376,16 +428,21 @@ describe("API Tests", () => {
 		});
 
 		test("should mute the specified user and return an APIRelationship object with notifications set to true", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user2.id}/mute`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({ notifications: false }),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user2.id}/mute`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({ notifications: false }),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -403,14 +460,13 @@ describe("API Tests", () => {
 
 	describe("GET /api/v1/mutes", () => {
 		test("should return an array of APIAccount objects for the user's muted accounts", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/mutes`,
-				{
+			const response = await sendTestRequest(
+				new Request(wrapRelativeUrl("/api/v1/mutes", base_url), {
 					method: "GET",
 					headers: {
 						Authorization: `Bearer ${token.access_token}`,
 					},
-				}
+				})
 			);
 
 			expect(response.status).toBe(200);
@@ -428,16 +484,21 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/accounts/:id/unmute", () => {
 		test("should unmute the specified user and return an APIRelationship object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user2.id}/unmute`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({}),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user2.id}/unmute`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({}),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -454,16 +515,21 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/accounts/:id/pin", () => {
 		test("should pin the specified user and return an APIRelationship object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user2.id}/pin`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({}),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user2.id}/pin`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({}),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -480,16 +546,21 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/accounts/:id/unpin", () => {
 		test("should unpin the specified user and return an APIRelationship object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user2.id}/unpin`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({}),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user2.id}/unpin`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({}),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -506,16 +577,21 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/accounts/:id/note", () => {
 		test("should update the specified account's note and return the updated account object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user2.id}/note`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({ comment: "This is a new note" }),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user2.id}/note`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({ comment: "This is a new note" }),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -532,14 +608,19 @@ describe("API Tests", () => {
 
 	describe("GET /api/v1/accounts/relationships", () => {
 		test("should return an array of APIRelationship objects for the authenticated user's relationships", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/relationships?id[]=${user2.id}`,
-				{
-					method: "GET",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/relationships?id[]=${user2.id}`,
+						base_url
+					),
+					{
+						method: "GET",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -565,15 +646,17 @@ describe("API Tests", () => {
 
 	describe("DELETE /api/v1/profile/avatar", () => {
 		test("should delete the avatar of the authenticated user and return the updated account object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/profile/avatar`,
-				{
-					method: "DELETE",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl("/api/v1/profile/avatar", base_url),
+					{
+						method: "DELETE",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -590,15 +673,17 @@ describe("API Tests", () => {
 
 	describe("DELETE /api/v1/profile/header", () => {
 		test("should delete the header of the authenticated user and return the updated account object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/profile/header`,
-				{
-					method: "DELETE",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl("/api/v1/profile/header", base_url),
+					{
+						method: "DELETE",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -615,16 +700,21 @@ describe("API Tests", () => {
 
 	describe("GET /api/v1/accounts/familiar_followers", () => {
 		test("should follow the user", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user2.id}/follow`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({}),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/${user2.id}/follow`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({}),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -634,14 +724,19 @@ describe("API Tests", () => {
 		});
 
 		test("should return an array of objects with id and accounts properties, where id is a string and accounts is an array of APIAccount objects", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/familiar_followers?id[]=${user2.id}`,
-				{
-					method: "GET",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`/api/v1/accounts/familiar_followers?id[]=${user2.id}`,
+						base_url
+					),
+					{
+						method: "GET",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
diff --git a/tests/api/statuses.test.ts b/tests/api/statuses.test.ts
index 3d9c1ea2..94bd9287 100644
--- a/tests/api/statuses.test.ts
+++ b/tests/api/statuses.test.ts
@@ -1,6 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { getConfig } from "@config";
 import type { Token } from "@prisma/client";
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { client } from "~database/datasource";
@@ -13,8 +10,11 @@ import type { APIAccount } from "~types/entities/account";
 import type { APIAsyncAttachment } from "~types/entities/async_attachment";
 import type { APIContext } from "~types/entities/context";
 import type { APIStatus } from "~types/entities/status";
+import { ConfigManager } from "config-manager";
+import { sendTestRequest, wrapRelativeUrl } from "~tests/utils";
 
-const config = getConfig();
+const config = await new ConfigManager({}).getConfig();
+const base_url = config.http.base_url;
 
 let token: Token;
 let user: UserWithRelations;
@@ -73,6 +73,12 @@ describe("API Tests", () => {
 				},
 			},
 		});
+
+		await client.application.deleteMany({
+			where: {
+				client_id: "test",
+			},
+		});
 	});
 
 	describe("POST /api/v2/media", () => {
@@ -80,16 +86,17 @@ describe("API Tests", () => {
 			const formData = new FormData();
 			formData.append("file", new Blob(["test"], { type: "text/plain" }));
 
-			// @ts-expect-error FormData is not iterable
-			const response = await fetch(
-				`${config.http.base_url}/api/v2/media`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-					},
-					body: formData,
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(`${base_url}/api/v2/media`, base_url),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+						},
+						body: formData,
+					}
+				)
 			);
 
 			expect(response.status).toBe(202);
@@ -107,20 +114,22 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/statuses", () => {
 		test("should create a new status and return an APIStatus object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/statuses`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({
-						status: "Hello, world!",
-						visibility: "public",
-						media_ids: [media1?.id],
-					}),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(`${base_url}/api/v1/statuses`, base_url),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({
+							status: "Hello, world!",
+							visibility: "public",
+							media_ids: [media1?.id],
+						}),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -130,14 +139,14 @@ describe("API Tests", () => {
 
 			// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
 			status = (await response.json()) as APIStatus;
-			expect(status.content).toBe("Hello, world!");
+			expect(status.content).toContain("Hello, world!");
 			expect(status.visibility).toBe("public");
 			expect(status.account.id).toBe(user.id);
 			expect(status.replies_count).toBe(0);
 			expect(status.favourites_count).toBe(0);
 			expect(status.reblogged).toBe(false);
 			expect(status.favourited).toBe(false);
-			expect(status.media_attachments).toEqual([]);
+			expect(status.media_attachments).toBeArrayOfSize(1);
 			expect(status.mentions).toEqual([]);
 			expect(status.tags).toEqual([]);
 			expect(status.sensitive).toBe(false);
@@ -153,20 +162,22 @@ describe("API Tests", () => {
 		});
 
 		test("should create a new status in reply to the previous one", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/statuses`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify({
-						status: "This is a reply!",
-						visibility: "public",
-						in_reply_to_id: status?.id,
-					}),
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(`${base_url}/api/v1/statuses`, base_url),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify({
+							status: "This is a reply!",
+							visibility: "public",
+							in_reply_to_id: status?.id,
+						}),
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -176,7 +187,7 @@ describe("API Tests", () => {
 
 			// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
 			status2 = (await response.json()) as APIStatus;
-			expect(status2.content).toBe("This is a reply!");
+			expect(status2.content).toContain("This is a reply!");
 			expect(status2.visibility).toBe("public");
 			expect(status2.account.id).toBe(user.id);
 			expect(status2.replies_count).toBe(0);
@@ -201,14 +212,20 @@ describe("API Tests", () => {
 
 	describe("GET /api/v1/statuses/:id", () => {
 		test("should return the specified status object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/statuses/${status?.id}`,
-				{
-					method: "GET",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`${base_url}/api/v1/statuses/${status?.id}`,
+						base_url
+					),
+					{
+						method: "GET",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -246,15 +263,20 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/statuses/:id/reblog", () => {
 		test("should reblog the specified status and return the reblogged status object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/statuses/${status?.id}/reblog`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`${base_url}/api/v1/statuses/${status?.id}/reblog`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -272,15 +294,20 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/statuses/:id/unreblog", () => {
 		test("should unreblog the specified status and return the original status object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/statuses/${status?.id}/unreblog`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`${base_url}/api/v1/statuses/${status?.id}/unreblog`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -297,15 +324,20 @@ describe("API Tests", () => {
 
 	describe("GET /api/v1/statuses/:id/context", () => {
 		test("should return the context of the specified status", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/statuses/${status?.id}/context`,
-				{
-					method: "GET",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`${base_url}/api/v1/statuses/${status?.id}/context`,
+						base_url
+					),
+					{
+						method: "GET",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -325,14 +357,20 @@ describe("API Tests", () => {
 
 	describe("GET /api/v1/timelines/public", () => {
 		test("should return an array of APIStatus objects that includes the created status", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/timelines/public`,
-				{
-					method: "GET",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`${base_url}/api/v1/timelines/public`,
+						base_url
+					),
+					{
+						method: "GET",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -348,15 +386,20 @@ describe("API Tests", () => {
 
 	describe("GET /api/v1/accounts/:id/statuses", () => {
 		test("should return the statuses of the specified user", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/accounts/${user.id}/statuses`,
-				{
-					method: "GET",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-						"Content-Type": "application/json",
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`${base_url}/api/v1/accounts/${user.id}/statuses`,
+						base_url
+					),
+					{
+						method: "GET",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -371,7 +414,7 @@ describe("API Tests", () => {
 			const status1 = statuses[0];
 
 			// Basic validation
-			expect(status1.content).toBe("This is a reply!");
+			expect(status1.content).toContain("This is a reply!");
 			expect(status1.visibility).toBe("public");
 			expect(status1.account.id).toBe(user.id);
 		});
@@ -379,14 +422,20 @@ describe("API Tests", () => {
 
 	describe("POST /api/v1/statuses/:id/favourite", () => {
 		test("should favourite the specified status object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/statuses/${status?.id}/favourite`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`${base_url}/api/v1/statuses/${status?.id}/favourite`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -395,14 +444,20 @@ describe("API Tests", () => {
 
 	describe("GET /api/v1/statuses/:id/favourited_by", () => {
 		test("should return an array of User objects who favourited the specified status", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/statuses/${status?.id}/favourited_by`,
-				{
-					method: "GET",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`${base_url}/api/v1/statuses/${status?.id}/favourited_by`,
+						base_url
+					),
+					{
+						method: "GET",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -420,14 +475,20 @@ describe("API Tests", () => {
 	describe("POST /api/v1/statuses/:id/unfavourite", () => {
 		test("should unfavourite the specified status object", async () => {
 			// Unfavourite the status
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/statuses/${status?.id}/unfavourite`,
-				{
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`${base_url}/api/v1/statuses/${status?.id}/unfavourite`,
+						base_url
+					),
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+							"Content-Type": "application/json",
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
@@ -444,14 +505,19 @@ describe("API Tests", () => {
 
 	describe("DELETE /api/v1/statuses/:id", () => {
 		test("should delete the specified status object", async () => {
-			const response = await fetch(
-				`${config.http.base_url}/api/v1/statuses/${status?.id}`,
-				{
-					method: "DELETE",
-					headers: {
-						Authorization: `Bearer ${token.access_token}`,
-					},
-				}
+			const response = await sendTestRequest(
+				new Request(
+					wrapRelativeUrl(
+						`${base_url}/api/v1/statuses/${status?.id}`,
+						base_url
+					),
+					{
+						method: "DELETE",
+						headers: {
+							Authorization: `Bearer ${token.access_token}`,
+						},
+					}
+				)
 			);
 
 			expect(response.status).toBe(200);
diff --git a/tests/cli.test.ts b/tests/cli.skip-test.ts
similarity index 100%
rename from tests/cli.test.ts
rename to tests/cli.skip-test.ts
diff --git a/tests/entities/Instance.test.ts b/tests/entities/Instance.test.ts
deleted file mode 100644
index e168dbce..00000000
--- a/tests/entities/Instance.test.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-/* import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import { AppDataSource } from "~database/datasource";
-import { Instance } from "~database/entities/Instance";
-
-let instance: Instance;
-
-beforeAll(async () => {
-	if (!AppDataSource.isInitialized) await AppDataSource.initialize();
-});
-
-describe("Instance", () => {
-	it("should add an instance to the database if it doesn't already exist", async () => {
-		const url = "https://mastodon.social";
-		instance = await Instance.addIfNotExists(url);
-		expect(instance.base_url).toBe("mastodon.social");
-	});
-});
-
-afterAll(async () => {
-	await instance.remove();
-
-	await AppDataSource.destroy();
-});
- */
diff --git a/tests/entities/Media.test.ts b/tests/entities/Media.test.ts
deleted file mode 100644
index df078d39..00000000
--- a/tests/entities/Media.test.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-import { type ConfigType, getConfig } from "@config";
-import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import { LocalBackend, S3Backend } from "~classes/media";
-import { unlink } from "fs/promises";
-import { DeleteObjectCommand } from "@aws-sdk/client-s3";
-
-const originalConfig = getConfig();
-const modifiedConfig: ConfigType = {
-	...originalConfig,
-	media: {
-		...originalConfig.media,
-		conversion: {
-			...originalConfig.media.conversion,
-			convert_images: false,
-		},
-	},
-};
-
-describe("LocalBackend", () => {
-	let localBackend: LocalBackend;
-	let fileName: string;
-
-	beforeAll(() => {
-		localBackend = new LocalBackend(modifiedConfig);
-	});
-
-	afterAll(async () => {
-		await unlink(`${process.cwd()}/uploads/${fileName}`);
-	});
-
-	describe("addMedia", () => {
-		it("should write the file to the local filesystem and return the hash", async () => {
-			const media = new File(["test"], "test.txt", {
-				type: "text/plain",
-			});
-
-			const hash = await localBackend.addMedia(media);
-			fileName = hash;
-
-			expect(hash).toBeDefined();
-		});
-	});
-
-	describe("getMediaByHash", () => {
-		it("should retrieve the file from the local filesystem and return it as a File object", async () => {
-			const media = await localBackend.getMediaByHash(fileName);
-
-			expect(media).toBeInstanceOf(File);
-		});
-
-		it("should return null if the file does not exist", async () => {
-			const media =
-				await localBackend.getMediaByHash("does-not-exist.txt");
-
-			expect(media).toBeNull();
-		});
-	});
-});
-
-describe("S3Backend", () => {
-	const s3Backend = new S3Backend(modifiedConfig);
-	let fileName: string;
-
-	afterAll(async () => {
-		const command = new DeleteObjectCommand({
-			Bucket: modifiedConfig.s3.bucket_name,
-			Key: fileName,
-		});
-
-		await s3Backend.client.send(command);
-	});
-
-	describe("addMedia", () => {
-		it("should write the file to the S3 bucket and return the hash", async () => {
-			const media = new File(["test"], "test.txt", {
-				type: "text/plain",
-			});
-
-			const hash = await s3Backend.addMedia(media);
-			fileName = hash;
-
-			expect(hash).toBeDefined();
-		});
-	});
-
-	describe("getMediaByHash", () => {
-		it("should retrieve the file from the S3 bucket and return it as a File object", async () => {
-			const media = await s3Backend.getMediaByHash(fileName);
-
-			expect(media).toBeInstanceOf(File);
-		});
-
-		it("should return null if the file does not exist", async () => {
-			const media = await s3Backend.getMediaByHash("does-not-exist.txt");
-
-			expect(media).toBeNull();
-		});
-	});
-});
diff --git a/tests/inbox.test.ts b/tests/inbox.test.ts
deleted file mode 100644
index fab17ac7..00000000
--- a/tests/inbox.test.ts
+++ /dev/null
@@ -1 +0,0 @@
-// Empty file
diff --git a/tests/oauth.test.ts b/tests/oauth.test.ts
index 6147d07b..3de351d4 100644
--- a/tests/oauth.test.ts
+++ b/tests/oauth.test.ts
@@ -1,10 +1,11 @@
-import { getConfig } from "@config";
 import type { Application, Token } from "@prisma/client";
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { client } from "~database/datasource";
 import { createNewLocalUser } from "~database/entities/User";
+import { sendTestRequest, wrapRelativeUrl } from "./utils";
 
-const config = getConfig();
+// const config = await new ConfigManager({}).getConfig();
+const base_url = "http://lysand.localhost:8080"; //config.http.base_url;
 
 let client_id: string;
 let client_secret: string;
@@ -30,17 +31,18 @@ describe("POST /api/v1/apps/", () => {
 		formData.append("redirect_uris", "https://example.com");
 		formData.append("scopes", "read write");
 
-		// @ts-expect-error FormData works
-		const response = await fetch(`${config.http.base_url}/api/v1/apps/`, {
-			method: "POST",
-			body: formData,
-		});
+		const response = await sendTestRequest(
+			new Request(wrapRelativeUrl("/api/v1/apps/", base_url), {
+				method: "POST",
+				body: formData,
+			})
+		);
 
 		expect(response.status).toBe(200);
 		expect(response.headers.get("content-type")).toBe("application/json");
 
 		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-		const json = (await response.json()) as any;
+		const json = await response.json();
 
 		expect(json).toEqual({
 			id: expect.any(String),
@@ -66,15 +68,19 @@ describe("POST /auth/login/", () => {
 		formData.append("email", "test@test.com");
 		formData.append("password", "test");
 
-		// @ts-expect-error FormData works
-		const response = await fetch(
-			`${config.http.base_url}/auth/login/?client_id=${client_id}&redirect_uri=https://example.com&response_type=code&scope=read+write`,
-			{
-				method: "POST",
-				body: formData,
-				redirect: "manual",
-			}
+		const response = await sendTestRequest(
+			new Request(
+				wrapRelativeUrl(
+					`/auth/login/?client_id=${client_id}&redirect_uri=https://example.com&response_type=code&scope=read+write`,
+					base_url
+				),
+				{
+					method: "POST",
+					body: formData,
+				}
+			)
 		);
+
 		expect(response.status).toBe(302);
 		expect(response.headers.get("Location")).toMatch(
 			/https:\/\/example.com\?code=/
@@ -96,15 +102,15 @@ describe("POST /oauth/token/", () => {
 		formData.append("client_secret", client_secret);
 		formData.append("scope", "read+write");
 
-		// @ts-expect-error FormData works
-		const response = await fetch(`${config.http.base_url}/oauth/token/`, {
-			method: "POST",
-			// Do not set the Content-Type header for some reason
-			body: formData,
-		});
+		const response = await sendTestRequest(
+			new Request(wrapRelativeUrl("/oauth/token/", base_url), {
+				method: "POST",
+				body: formData,
+			})
+		);
 
 		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-		const json = (await response.json()) as any;
+		const json = await response.json();
 
 		expect(response.status).toBe(200);
 		expect(response.headers.get("content-type")).toBe("application/json");
@@ -122,15 +128,15 @@ describe("POST /oauth/token/", () => {
 
 describe("GET /api/v1/apps/verify_credentials", () => {
 	test("should return the authenticated application's credentials", async () => {
-		const response = await fetch(
-			`${config.http.base_url}/api/v1/apps/verify_credentials`,
-			{
-				method: "GET",
-				headers: {
-					Authorization: `Bearer ${token.access_token}`,
-					"Content-Type": "application/json",
-				},
-			}
+		const response = await sendTestRequest(
+			new Request(
+				wrapRelativeUrl("/api/v1/apps/verify_credentials", base_url),
+				{
+					headers: {
+						Authorization: `Bearer ${token.access_token}`,
+					},
+				}
+			)
 		);
 
 		expect(response.status).toBe(200);
diff --git a/tests/utils.ts b/tests/utils.ts
new file mode 100644
index 00000000..60de2330
--- /dev/null
+++ b/tests/utils.ts
@@ -0,0 +1,15 @@
+import { server } from "~index";
+
+/**
+ * This allows us to send a test request to the server even when it isnt running
+ * CURRENTLY NOT WORKING, NEEDS TO BE FIXED
+ * @param req Request to send
+ * @returns Response from the server
+ */
+export async function sendTestRequest(req: Request) {
+	return server.fetch(req);
+}
+
+export function wrapRelativeUrl(url: string, base_url: string) {
+	return new URL(url, base_url);
+}
diff --git a/tsconfig.json b/tsconfig.json
index 1461898f..ef00e6ba 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,6 +1,6 @@
 {
 	"compilerOptions": {
-		"lib": ["ESNext"],
+		"lib": ["ESNext", "DOM", "DOM.Iterable"],
 		"module": "esnext",
 		"target": "esnext",
 		"moduleResolution": "bundler",
@@ -26,12 +26,15 @@
 		],
 		"paths": {
 			"@*": ["./utils/*"],
-			"~*": ["./*"]
+			"~*": ["./*"],
+			"+*": ["./server/api/*"],
 		},
 	},
 	"include": [
 		"*.ts",
+		"*.vue",
 		"**/*.ts",
+		"**/*.vue",
 		"server/api/.well-known/**/*.ts"
 	]
 }
diff --git a/types/activitypub.ts b/types/activitypub.ts
new file mode 100644
index 00000000..619b8563
--- /dev/null
+++ b/types/activitypub.ts
@@ -0,0 +1,141 @@
+export type APActivityPubContext =
+	| "https://www.w3.org/ns/activitystreams"
+	| {
+			ostatus: string;
+			atomUri: string;
+			inReplyToAtomUri: string;
+			conversation: string;
+			sensitive: string;
+			toot: string;
+			votersCount: string;
+			litepub: string;
+			directMessage: string;
+	  };
+
+export interface APActivityPubObject {
+	id: string;
+	type: string;
+	summary?: string;
+	inReplyTo?: string;
+	published: string;
+	url: string;
+	attributedTo: string;
+	to: string[];
+	cc: string[];
+	sensitive?: boolean;
+	atomUri: string;
+	inReplyToAtomUri?: string;
+	conversation: string;
+	content: string;
+	contentMap: Record<string, string>;
+	attachment: APActivityPubAttachment[];
+	tag: APTag[];
+	context?: string;
+	quoteUri?: string;
+	quoteUrl?: string;
+	source?: {
+		content: string;
+		mediaType: string;
+	};
+}
+
+export interface APActivityPubAttachment {
+	type?: string;
+	mediaType?: string;
+	url?: string;
+	name?: string;
+}
+
+export interface APActivityPubCollection {
+	id: string;
+	type: string;
+	first?: {
+		type: string;
+		next: string;
+		partOf: string;
+		items: any[]; // replace any with your item type
+	};
+}
+
+export interface APActivityPubNote extends APActivityPubObject {
+	type: "Note";
+}
+
+export interface APActivityPubActivity {
+	"@context": APActivityPubContext[];
+	id: string;
+	type: string;
+	actor: string;
+	published: string;
+	to: string[];
+	cc: string[];
+	object: APActivityPubNote;
+}
+
+export type APActorContext =
+	| "https://www.w3.org/ns/activitystreams"
+	| "https://w3id.org/security/v1"
+	| Record<
+			string,
+			| string
+			| { "@id": string; "@type": string }
+			| { "@container": string; "@id": string }
+	  >;
+
+export interface APActorPublicKey {
+	id: string;
+	owner: string;
+	publicKeyPem: string;
+}
+
+export interface APActorEndpoints {
+	sharedInbox: string;
+}
+
+export interface APActorIcon {
+	type: string;
+	mediaType: string;
+	url: string;
+}
+
+export interface APActor {
+	"@context": APActorContext[];
+	id: string;
+	type: string;
+	following: string;
+	followers: string;
+	inbox: string;
+	outbox: string;
+	featured: string;
+	featuredTags: string;
+	preferredUsername: string;
+	name: string;
+	summary: string;
+	url: string;
+	manuallyApprovesFollowers: boolean;
+	discoverable: boolean;
+	indexable: boolean;
+	published: string;
+	memorial: boolean;
+	devices: string;
+	publicKey: APActorPublicKey;
+	tag: APTag[];
+	attachment: APAttachment[];
+	endpoints: APActorEndpoints;
+	icon: APActorIcon;
+}
+
+export interface APTag {
+	type: string;
+	href: string;
+	name: string;
+}
+
+export interface APAttachment {
+	type: string;
+	mediaType: string;
+	url: string;
+	name?: string;
+	blurhash?: string;
+	description?: string;
+}
diff --git a/types/entities/instance.ts b/types/entities/instance.ts
index 2194f258..f1efd08a 100644
--- a/types/entities/instance.ts
+++ b/types/entities/instance.ts
@@ -3,6 +3,7 @@ import type { APIStats } from "./stats";
 import type { APIURLs } from "./urls";
 
 export interface APIInstance {
+	tos_url: string | undefined;
 	uri: string;
 	title: string;
 	description: string;
diff --git a/utils/api.ts b/utils/api.ts
index 0e088cdd..283cf136 100644
--- a/utils/api.ts
+++ b/utils/api.ts
@@ -1,8 +1,10 @@
-import { getConfig } from "@config";
+import { ConfigManager } from "config-manager";
+import type { RouteHandler } from "~server/api/routes.type";
 import type { APIRouteMeta } from "~types/api";
 
+const config = await new ConfigManager({}).getConfig();
+
 export const applyConfig = (routeMeta: APIRouteMeta) => {
-	const config = getConfig();
 	const newMeta = routeMeta;
 
 	// Apply ratelimits from config
@@ -16,3 +18,7 @@ export const applyConfig = (routeMeta: APIRouteMeta) => {
 
 	return newMeta;
 };
+
+export const apiRoute = <T>(routeFunction: RouteHandler<T>) => {
+	return routeFunction;
+};
diff --git a/utils/constants.ts b/utils/constants.ts
new file mode 100644
index 00000000..4de00425
--- /dev/null
+++ b/utils/constants.ts
@@ -0,0 +1,6 @@
+import { ConfigManager } from "config-manager";
+
+const config = await new ConfigManager({}).getConfig();
+
+export const oauthRedirectUri = (issuer: string) =>
+	`${config.http.base_url}/oauth/callback/${issuer}`;
diff --git a/utils/formatting.ts b/utils/formatting.ts
new file mode 100644
index 00000000..1cb56e15
--- /dev/null
+++ b/utils/formatting.ts
@@ -0,0 +1,29 @@
+import { sanitizeHtml } from "@sanitization";
+import linkifyHtml from "linkify-html";
+import linkifyStr from "linkify-string";
+import { parse } from "marked";
+
+/**
+ * Converts plaintext, MFM or Markdown to HTML
+ * @param text Text to convert
+ * @param content_type Content type of the text (optional, defaults to plaintext)
+ * @returns HTML
+ */
+export const convertTextToHtml = async (
+	text: string,
+	content_type?: string
+) => {
+	if (content_type === "text/markdown") {
+		return linkifyHtml(await sanitizeHtml(await parse(text)));
+	} else if (content_type === "text/x.misskeymarkdown") {
+		// Parse as MFM
+		// TODO: Implement MFM
+		return text;
+	} else {
+		// Parse as plaintext
+		return linkifyStr(text)
+			.split("\n")
+			.map(line => `<p>${line}</p>`)
+			.join("\n");
+	}
+};
diff --git a/utils/meilisearch.ts b/utils/meilisearch.ts
new file mode 100644
index 00000000..e885ddbc
--- /dev/null
+++ b/utils/meilisearch.ts
@@ -0,0 +1,176 @@
+import chalk from "chalk";
+import { client } from "~database/datasource";
+import { Meilisearch } from "meilisearch";
+import type { Status, User } from "@prisma/client";
+import { ConfigManager } from "config-manager";
+import { LogLevel, type LogManager, type MultiLogManager } from "log-manager";
+
+const config = await new ConfigManager({}).getConfig();
+
+export const meilisearch = new Meilisearch({
+	host: `${config.meilisearch.host}:${config.meilisearch.port}`,
+	apiKey: config.meilisearch.api_key,
+});
+
+export const connectMeili = async (logger: MultiLogManager | LogManager) => {
+	if (!config.meilisearch.enabled) return;
+
+	if (await meilisearch.isHealthy()) {
+		await meilisearch
+			.index(MeiliIndexType.Accounts)
+			.updateSortableAttributes(["createdAt"]);
+
+		await meilisearch
+			.index(MeiliIndexType.Accounts)
+			.updateSearchableAttributes(["username", "displayName", "note"]);
+
+		await meilisearch
+			.index(MeiliIndexType.Statuses)
+			.updateSortableAttributes(["createdAt"]);
+
+		await meilisearch
+			.index(MeiliIndexType.Statuses)
+			.updateSearchableAttributes(["content"]);
+
+		await logger.log(
+			LogLevel.INFO,
+			"Meilisearch",
+			"Connected to Meilisearch"
+		);
+	} else {
+		await logger.log(
+			LogLevel.CRITICAL,
+			"Meilisearch",
+			"Error while connecting to Meilisearch"
+		);
+		process.exit(1);
+	}
+};
+
+export enum MeiliIndexType {
+	Accounts = "accounts",
+	Statuses = "statuses",
+}
+
+export const addStausToMeilisearch = async (status: Status) => {
+	if (!config.meilisearch.enabled) return;
+
+	await meilisearch.index(MeiliIndexType.Statuses).addDocuments([
+		{
+			id: status.id,
+			content: status.content,
+			createdAt: status.createdAt,
+		},
+	]);
+};
+
+export const addUserToMeilisearch = async (user: User) => {
+	if (!config.meilisearch.enabled) return;
+
+	await meilisearch.index(MeiliIndexType.Accounts).addDocuments([
+		{
+			id: user.id,
+			username: user.username,
+			displayName: user.displayName,
+			note: user.note,
+			createdAt: user.createdAt,
+		},
+	]);
+};
+
+export const getNthDatabaseAccountBatch = (
+	n: number,
+	batchSize = 1000
+): Promise<Record<string, string | Date>[]> => {
+	return client.user.findMany({
+		skip: n * batchSize,
+		take: batchSize,
+		select: {
+			id: true,
+			username: true,
+			displayName: true,
+			note: true,
+			createdAt: true,
+		},
+		orderBy: {
+			createdAt: "asc",
+		},
+	});
+};
+
+export const getNthDatabaseStatusBatch = (
+	n: number,
+	batchSize = 1000
+): Promise<Record<string, string | Date>[]> => {
+	return client.status.findMany({
+		skip: n * batchSize,
+		take: batchSize,
+		select: {
+			id: true,
+			content: true,
+			createdAt: true,
+		},
+		orderBy: {
+			createdAt: "asc",
+		},
+	});
+};
+
+export const rebuildSearchIndexes = async (
+	indexes: MeiliIndexType[],
+	batchSize = 100
+) => {
+	if (indexes.includes(MeiliIndexType.Accounts)) {
+		const accountCount = await client.user.count();
+
+		for (let i = 0; i < accountCount / batchSize; i++) {
+			const accounts = await getNthDatabaseAccountBatch(i, batchSize);
+
+			const progress = Math.round((i / (accountCount / batchSize)) * 100);
+
+			console.log(`${chalk.green(`✓`)} ${progress}%`);
+
+			// Sync with Meilisearch
+			await meilisearch
+				.index(MeiliIndexType.Accounts)
+				.addDocuments(accounts);
+		}
+
+		const meiliAccountCount = (
+			await meilisearch.index(MeiliIndexType.Accounts).getStats()
+		).numberOfDocuments;
+
+		console.log(
+			`${chalk.green(`✓`)} ${chalk.bold(
+				`Done! ${meiliAccountCount} accounts indexed`
+			)}`
+		);
+	}
+
+	if (indexes.includes(MeiliIndexType.Statuses)) {
+		const statusCount = await client.status.count();
+
+		for (let i = 0; i < statusCount / batchSize; i++) {
+			const statuses = await getNthDatabaseStatusBatch(i, batchSize);
+
+			const progress = Math.round((i / (statusCount / batchSize)) * 100);
+
+			console.log(`${chalk.green(`✓`)} ${progress}%`);
+
+			// Sync with Meilisearch
+			await meilisearch
+				.index(MeiliIndexType.Statuses)
+				.addDocuments(statuses);
+		}
+
+		const meiliStatusCount = (
+			await meilisearch.index(MeiliIndexType.Statuses).getStats()
+		).numberOfDocuments;
+
+		console.log(
+			`${chalk.green(`✓`)} ${chalk.bold(
+				`Done! ${meiliStatusCount} statuses indexed`
+			)}`
+		);
+	}
+};
diff --git a/utils/merge.ts b/utils/merge.ts
new file mode 100644
index 00000000..fe480b6d
--- /dev/null
+++ b/utils/merge.ts
@@ -0,0 +1,16 @@
+export const deepMerge = (
+	target: Record<string, any>,
+	source: Record<string, any>
+) => {
+	const result = { ...target, ...source };
+	for (const key of Object.keys(result)) {
+		result[key] =
+			typeof target[key] == "object" && typeof source[key] == "object"
+				? deepMerge(target[key], source[key])
+				: structuredClone(result[key]);
+	}
+	return result;
+};
+
+export const deepMergeArray = (array: Record<string, any>[]) =>
+	array.reduce((ci, ni) => deepMerge(ci, ni), {});
diff --git a/utils/module.ts b/utils/module.ts
new file mode 100644
index 00000000..212d863c
--- /dev/null
+++ b/utils/module.ts
@@ -0,0 +1,31 @@
+import { fileURLToPath } from "url";
+
+/**
+ * Determines whether a module is the entry point for the running node process.
+ * This works for both CommonJS and ES6 environments.
+ *
+ * ### CommonJS
+ * ```js
+ * if (moduleIsEntry(module)) {
+ *     console.log('WOO HOO!!!');
+ * }
+ * ```
+ *
+ * ### ES6
+ * ```js
+ * if (moduleIsEntry(import.meta.url)) {
+ *     console.log('WOO HOO!!!');
+ * }
+ * ```
+ */
+export const moduleIsEntry = (moduleOrImportMetaUrl: NodeModule | string) => {
+	if (typeof moduleOrImportMetaUrl === "string") {
+		return process.argv[1] === fileURLToPath(moduleOrImportMetaUrl);
+	}
+
+	if (typeof require !== "undefined" && "exports" in moduleOrImportMetaUrl) {
+		return require.main === moduleOrImportMetaUrl;
+	}
+
+	return false;
+};
diff --git a/utils/oauth.ts b/utils/oauth.ts
index bc9110e1..f095242d 100644
--- a/utils/oauth.ts
+++ b/utils/oauth.ts
@@ -59,3 +59,5 @@ export const checkIfOauthIsValid = (
 
 	return false;
 };
+
+export const oauthCodeVerifiers: Record<string, string> = {};
diff --git a/utils/redis.ts b/utils/redis.ts
index a5715bc1..e6d61910 100644
--- a/utils/redis.ts
+++ b/utils/redis.ts
@@ -1,10 +1,10 @@
-import { getConfig } from "@config";
 import type { Prisma } from "@prisma/client";
 import chalk from "chalk";
+import { ConfigManager } from "config-manager";
 import Redis from "ioredis";
 import { createPrismaRedisCache } from "prisma-redis-middleware";
 
-const config = getConfig();
+const config = await new ConfigManager({}).getConfig();
 
 const cacheRedis = config.redis.cache.enabled
 	? new Redis({
@@ -12,7 +12,7 @@ const cacheRedis = config.redis.cache.enabled
 			port: Number(config.redis.cache.port),
 			password: config.redis.cache.password,
 			db: Number(config.redis.cache.database ?? 0),
-	  })
+		})
 	: null;
 
 cacheRedis?.on("error", e => {
diff --git a/utils/request.ts b/utils/request.ts
deleted file mode 100644
index e4fa0e52..00000000
--- a/utils/request.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * Takes a request, and turns FormData or query parameters
- * into a JSON object as would be returned by req.json()
- * This is a translation layer that allows clients to use
- * either FormData, query parameters, or JSON in the request
- * @param request The request to parse
- */
-export async function parseRequest<T>(request: Request): Promise<Partial<T>> {
-	const query = new URL(request.url).searchParams;
-	let output: Partial<T> = {};
-
-	// Parse SearchParams arrays into JSON arrays
-	const arrayKeys = [...query.keys()].filter(key => key.endsWith("[]"));
-	const nonArrayKeys = [...query.keys()].filter(key => !key.endsWith("[]"));
-
-	for (const key of arrayKeys) {
-		const value = query.getAll(key);
-		query.delete(key);
-		query.append(key, JSON.stringify(value));
-	}
-
-	// Append non array keys to output
-	for (const key of nonArrayKeys) {
-		// @ts-expect-error Complains about type
-		output[key] = query.get(key);
-	}
-
-	const queryEntries = [...query.entries()];
-
-	if (queryEntries.length > 0) {
-		const data: Record<string, string | string[]> = {};
-
-		const arrayKeys = [...query.keys()].filter(key => key.endsWith("[]"));
-
-		for (const key of arrayKeys) {
-			const value = query.getAll(key);
-			query.delete(key);
-			// @ts-expect-error JSON arrays are valid
-			data[key] = JSON.parse(value);
-		}
-
-		output = {
-			...output,
-			...(data as T),
-		};
-	}
-
-	// if request contains a JSON body
-	if (request.headers.get("Content-Type")?.includes("application/json")) {
-		try {
-			output = {
-				...output,
-				...((await request.json()) as T),
-			};
-		} catch {
-			// Invalid JSON
-		}
-	}
-
-	// If request contains FormData
-	if (request.headers.get("Content-Type")?.includes("multipart/form-data")) {
-		const formData = [...(await request.formData()).entries()];
-
-		if (formData.length > 0) {
-			const data: Record<string, string | File> = {};
-
-			for (const [key, value] of formData) {
-				// If object, parse as JSON
-				try {
-					// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-base-to-string
-					data[key] = JSON.parse(value.toString());
-				} catch {
-					// If a file, set as a file
-					if (value instanceof File) {
-						data[key] = value;
-					} else {
-						// Otherwise, set as a string
-						// eslint-disable-next-line @typescript-eslint/no-base-to-string
-						data[key] = value.toString();
-					}
-				}
-			}
-
-			output = {
-				...output,
-				...(data as T),
-			};
-		}
-	}
-
-	return output;
-}
diff --git a/utils/sanitization.ts b/utils/sanitization.ts
index 7512a063..e2426b95 100644
--- a/utils/sanitization.ts
+++ b/utils/sanitization.ts
@@ -1,8 +1,8 @@
-import { getConfig } from "@config";
+import { ConfigManager } from "config-manager";
 import { sanitize } from "isomorphic-dompurify";
 
 export const sanitizeHtml = async (html: string) => {
-	const config = getConfig();
+	const config = await new ConfigManager({}).getConfig();
 
 	const sanitizedHtml = sanitize(html, {
 		ALLOWED_TAGS: [
diff --git a/utils/temp.ts b/utils/temp.ts
new file mode 100644
index 00000000..efea7158
--- /dev/null
+++ b/utils/temp.ts
@@ -0,0 +1,20 @@
+import { join } from "path";
+import { exists, mkdir, writeFile, readFile } from "fs/promises";
+
+export const writeToTempDirectory = async (filename: string, data: string) => {
+	const tempDir = join("/tmp/", "lysand");
+	if (!(await exists(tempDir))) await mkdir(tempDir);
+
+	const tempFile = join(tempDir, filename);
+	await writeFile(tempFile, data);
+
+	return tempFile;
+};
+
+export const readFromTempDirectory = async (filename: string) => {
+	const tempDir = join("/tmp/", "lysand");
+	if (!(await exists(tempDir))) await mkdir(tempDir);
+
+	const tempFile = join(tempDir, filename);
+	return readFile(tempFile, "utf-8");
+};