@devchitchat/chat 0.0.0

package/README.md

@@ -0,0 +1,313 @@
+# Dev Chit Chat
+
+In 2009, at the Velocity conference, a couple of guys who worked at Flickr presented how development and operations fits toghether and gets along ... at Flickr.
+
+The premise is kinda of dumb. Like, why was there even a Devs vs Ops mentality? Regardless, it was real. We were all working on systems and under pressure to build stuff that, quite frankly, was hard.
+
+Anyways, that was the inspiration. Since then, I've championed just collaborating with each other as we build things together.
+
+Along with this, Agile had already been getting traction in corporate America. Scrum was being used to run teams. And Daily Standups were becoing the norm.
+
+In 2013 Github released Hubot as open source, it's home grown chat bot.
+
+I was at GameStop at this time, managing my first team. I saw first hand what a DevOps culture felt like. We deployed the system every week. It was amazing.
+
+Dev Chit Chat came out of that experience and time. Developers meeting daily chit chatting about what they were going to do today, what they learned, etc.
+
+# A Story
+
+I want a chat system that works like Discord, but I don't need the scalability of Discord. I'm just using it for my friends, small teams, not 1000 member community.
+
+Bun is fast and javascript is fine. So let's leverage the accessiblity of both to build a small chat system that does video, audio and screenshare live streaming.
+
+I run bun start the first time and I see a bootstrapping invite code in the console. I double-click on it and copy it to pasteboard. Then I visit https://joey-mac-mini.local:3000 (use your machine name instead of mine in hte URL) and enter it on the signup page to create the first account, it's the admin.
+
+Upon signing in the first time, there's no communication hubs or channels. So we need to create the first ones first so the app can be in a useable state.
+
+The system should just create a default hub and channel. That way, on bootstrap, the system is useable right off the bat. I can start chatting in a channel.
+
+---
+
+# Getting Started
+
+## Prerequisites
+
+- [Bun](https://bun.sh) v1.0 or later
+
+## Install
+
+```bash
+bun install
+```
+
+## HTTPS requirement
+
+Text chat works over plain HTTP. However, browsers block camera, microphone, and screen-share access on non-secure origins, so **HTTPS is required for video and audio calls**.
+
+### Create a self-signed certificate
+
+First, find your machine's hostname and LAN IP:
+
+```bash
+# macOS
+hostname          # e.g. joey-mac-mini.local
+ipconfig getifaddr en0   # e.g. 192.168.1.10
+
+# Linux
+hostname -f
+hostname -I | awk '{print $1}'
+```
+
+Then generate the certificate, substituting your actual hostname and IP:
+
+```bash
+mkdir -p certs
+openssl req -x509 -newkey rsa:2048 -sha256 -nodes -days 365 \
+  -keyout certs/dev-key.pem \
+  -out certs/dev-cert.pem \
+  -subj "/CN=joey-mac-mini.local" \
+  -addext "subjectAltName = IP:192.168.1.10"
+```
+
+The server looks for `certs/dev-cert.pem` and `certs/dev-key.pem` by default. You can override the paths with `TLS_CERT` and `TLS_KEY` environment variables (see below).
+
+On first visit the browser will warn about the self-signed cert — proceed past it and the warning won't reappear.
+
+### Trust the cert (optional but recommended)
+
+Trusting the cert silences the browser warning permanently.
+
+**macOS:**
+
+```bash
+sudo security add-trusted-cert -d -r trustRoot \
+  -k /Library/Keychains/System.keychain certs/dev-cert.pem
+```
+
+**Linux (Debian/Ubuntu):**
+
+```bash
+sudo cp certs/dev-cert.pem /usr/local/share/ca-certificates/devchitchat.crt
+sudo update-ca-certificates
+```
+
+**Windows:** Double-click `certs/dev-cert.pem`, choose "Install Certificate", place it in the "Trusted Root Certification Authorities" store.
+
+## Start the server
+
+```bash
+# Production
+bun start
+
+# Development (auto-restarts on file changes)
+bun dev
+```
+
+The server starts on port `3000` by default. Visit `https://<your-machine>.local:3000`.
+
+## First-time bootstrap
+
+On the very first run, an invite code is printed to the console:
+
+```
+Invite code: https://<your-machine>.local:3000/signup?code=<token>
+```
+
+Copy that URL and open it in a browser to create the first account, which becomes the admin. From there you can invite other users and set up hubs and channels.
+
+## Environment variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `PORT` | `3000` | Port the server listens on |
+| `DB_PATH` | `data/chat.db` | Path to the SQLite database file |
+| `NODE_ENV` | `development` | Set to `production` in production |
+| `TLS_CERT` | `certs/dev-cert.pem` | Path to the TLS certificate |
+| `TLS_KEY` | `certs/dev-key.pem` | Path to the TLS private key |
+
+## Run tests
+
+```bash
+bun test
+```
+
+## Backup and restore
+
+### Backup
+
+**Database:**
+
+```bash
+bun backup
+```
+
+Creates a clean binary copy of the database at `data/backups/chat-<timestamp>.db` using SQLite's `VACUUM INTO`. Safe to run against a live server.
+
+| Variable | Default | Description |
+|---|---|---|
+| `DB_PATH` | `data/chat.db` | Path to the source database |
+| `BACKUP_DIR` | `data/backups` | Directory where backups are written |
+
+**Uploads:**
+
+```bash
+bun backup-uploads
+```
+
+Mirrors the uploads directory to a backup location. Not versioned — overwrites the destination with the current state.
+
+| Variable | Default | Description |
+|---|---|---|
+| `UPLOAD_DIR` | `data/uploads` | Source uploads directory |
+| `UPLOADS_BACKUP_DIR` | `data/backups/uploads` | Backup destination |
+
+### Restore
+
+#### Local (bare Bun process)
+
+**Database:**
+
+1. Stop the server.
+2. Copy the backup over the live database:
+   ```bash
+   cp data/backups/chat-<timestamp>.db data/chat.db
+   ```
+3. Restart the server.
+
+**Uploads:**
+
+```bash
+cp -r data/backups/uploads data/uploads
+```
+
+#### Kubernetes (k3s)
+
+**Database:**
+
+```bash
+bun restore path/to/chat-<timestamp>.db
+```
+
+`scripts/restore.js` handles the full sequence automatically:
+
+1. Switches to the correct kubectl context
+2. Scales `chat-web` down to 0 and waits for termination
+3. Starts a temporary `busybox` helper pod mounting the `chat-web-sqlite` PVC
+4. Uploads the backup file to the pod
+5. Moves it into place as `/var/lib/chat/chat.db`
+6. Fixes file permissions so the app can write to the restored database
+7. Removes stale WAL/SHM files so SQLite opens cleanly
+8. Removes the temporary upload file
+9. Deletes the helper pod
+10. Scales `chat-web` back to 1 and waits for rollout
+
+If any step fails, the helper pod is cleaned up and the deployment is scaled back to 1 before exiting.
+
+**Uploads:**
+
+```bash
+bun restore-uploads path/to/uploads-backup
+```
+
+Copies the uploads directory into the PVC via a temporary helper pod. The deployment is not scaled down — uploads are static files and the copy is safe against a live server.
+
+**Cluster env vars (both restore scripts):**
+
+| Variable | Default | Description |
+|---|---|---|
+| `KUBE_CONTEXT` | `k3s-local` | kubectl context |
+| `KUBE_NAMESPACE` | `default` | Kubernetes namespace |
+
+#### Useful k8s backup operations
+
+```bash
+# Trigger the backup CronJob immediately (instead of waiting for the schedule)
+bun backup-now
+
+# Pull backups from the running pod to your local ../backups directory
+bun backup-pull
+```
+
+---
+
+# Docker / Kubernetes (k3s)
+
+The included scripts build a Docker image and load it into a local [k3s](https://k3s.io) cluster.
+
+## Cluster setup
+
+The cluster runs k3s inside a [Lima](https://lima-vm.io) VM. Lima auto-starts on boot via launchd, so the cluster survives power outages without requiring a user login.
+
+**One-time setup:**
+
+```bash
+brew install lima
+limactl start --name=k3s template://k3s
+```
+
+Merge the kubeconfig so `kubectl` can reach the cluster:
+
+```bash
+limactl kubeconfig k3s >> ~/.kube/config
+# or set KUBECONFIG directly:
+export KUBECONFIG="$HOME/.kube/config:$(limactl list k3s --format '{{.Dir}}/copied-from-guest/kubeconfig.yaml')"
+```
+
+The context is named `k3s-local` by default in this project's scripts. Rename it to match if yours differs:
+
+```bash
+kubectl config rename-context default k3s-local
+```
+
+**Backup paths:**
+
+Lima mounts your home directory into the VM at the same path, so backup paths in `charts/web/values.local.yaml` are regular host paths — no special volume flags needed at cluster creation. Set them in `values.local.yaml` (gitignored):
+
+```yaml
+dbBackupNodePath: /Users/yourname/backups/chat-web/db-backups
+uploadsBackupNodePath: /Users/yourname/backups/chat-web/uploads-backups
+```
+
+## Build and import into k3s
+
+```bash
+bun run docker-build
+# or directly:
+./docker-build-k3s.sh
+```
+
+This will:
+1. Bump the patch version in `package.json`
+2. Update the image tag in `charts/web/deployment.yaml`
+3. Build the Docker image (`local/chat-web:<version>`)
+4. Import the image into the Lima k3s instance via `limactl shell`
+
+`LIMA_INSTANCE` controls which Lima VM the image is imported into — it maps to the `<name>` in `limactl shell <name>`. If you started your VM with `limactl start --name=k3s`, you never need to set it. Only set it if you named your VM something other than `k3s`:
+
+```bash
+LIMA_INSTANCE=my-instance bun run docker-build
+```
+
+## Deploy to local cluster
+
+```bash
+bun run local-deploy
+```
+
+Applies `charts/web/deployment.yaml` to the `default` namespace of the `k3s-local` context.
+
+## Build + deploy in one step
+
+```bash
+bun run push
+```
+
+## Kubernetes environment variables
+
+Override defaults via `charts/web/deployment.yaml`:
+
+| Variable | Value in chart | Description |
+|---|---|---|
+| `PORT` | `8080` | Port the container exposes |
+| `NODE_ENV` | `production` | Runtime environment |
+| `DB_PATH` | `/var/lib/chat/chat.db` | SQLite path (backed by a 2 Gi PVC) |

package/index.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env bun
+import { createServer } from '@devchitchat/index97'
+import { openDatabase } from './src/db/openDb.js'
+import { initDb } from './src/db/initDb.js'
+import { runMigrations } from './src/db/runMigrations.js'
+import { createLogger } from './src/util/logger.js'
+import { ChatServer } from './src/ws/ChatServer.js'
+import { init as initContext, sessionFromRequest } from './src/context.js'
+import { UserSettingsService } from './src/services/UserSettingsService.js'
+import { SqliteUserSettingsRepository } from './src/adapters/SqliteUserSettingsRepository.js'
+import { UploadService } from './src/services/UploadService.js'
+import { LocalFileStore } from './src/adapters/LocalFileStore.js'
+import { SqliteUploadRepository } from './src/adapters/SqliteUploadRepository.js'
+
+/**
+ * Start the devchitchat server.
+ *
+ * @param {object} config
+ * @param {number}  [config.port]       - Port to listen on. Default: process.env.PORT ?? 3000
+ * @param {string}  [config.dbPath]     - Path to the SQLite database file. Default: process.env.DB_PATH ?? './data/chat.db'
+ * @param {string}  [config.basePath]   - URL subpath to mount the app at, e.g. '/chat'. Default: process.env.BASE_PATH ?? ''
+ * @param {boolean} [config.dev]        - Enable dev mode. Default: process.env.NODE_ENV !== 'production'
+ * @param {string}  [config.tlsCert]    - Path to TLS certificate. Default: process.env.TLS_CERT ?? './certs/dev-cert.pem'
+ * @param {string}  [config.tlsKey]     - Path to TLS private key. Default: process.env.TLS_KEY ?? './certs/dev-key.pem'
+ * @returns {Promise<import('bun').Server>}
+ */
+export async function start(config = {}) {
+  const {
+    port = Number(process.env.PORT ?? 3000),
+    dbPath = process.env.DB_PATH ?? './data/chat.db',
+    basePath = (process.env.BASE_PATH ?? '').replace(/\/$/, ''),
+    dev = process.env.NODE_ENV !== 'production',
+    tlsCert = process.env.TLS_CERT ?? './certs/dev-cert.pem',
+    tlsKey = process.env.TLS_KEY ?? './certs/dev-key.pem',
+  } = config
+
+  const p = path => `${basePath}${path}`
+
+  const logger = createLogger()
+  const db = openDatabase(dbPath)
+  initDb(db)
+  await runMigrations(db, { logger })
+
+  const chat = new ChatServer({ db, logger })
+  const userSettingsService = new UserSettingsService({ userSettingsRepo: new SqliteUserSettingsRepository({ db }) })
+  const uploadService = new UploadService({
+    uploadRepo: new SqliteUploadRepository({ db }),
+    fileStore: new LocalFileStore(),
+    channelService: chat.channelService,
+  })
+  chat.messageService.setUploadService(uploadService)
+
+  // Wire service context so page handlers (pages/**/*.js) can access services
+  initContext({
+    auth: chat.auth,
+    hubService: chat.hubService,
+    channelService: chat.channelService,
+    messageService: chat.messageService,
+    deliveryService: chat.deliveryService,
+    searchService: chat.searchService,
+    presenceService: chat.presenceService,
+    signalingService: chat.signalingService,
+    botService: chat.botService,
+    userSettingsService,
+    uploadService,
+    reactionService: chat.reactionService,
+    logger,
+  })
+
+  async function getTlsIfAvailable() {
+    const cert = Bun.file(tlsCert)
+    if (await cert.exists()) {
+      return { cert, key: Bun.file(tlsKey) }
+    }
+    return null
+  }
+
+  const server = await createServer({
+    pagesDir: import.meta.dir + '/pages',
+    port,
+    dev,
+    basePath,
+    // Allow camera/mic/display for WebRTC
+    permissionsPolicy: 'camera=(self), microphone=(self), display-capture=(self)',
+    // CSP: allow WebSocket connections to self
+    csp: "default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; connect-src 'self' ws: wss:",
+    // So the SSE doesn't timeout.
+    idleTimeout: 0,
+    // WebSocket upgrade route — authenticate via session cookie before the first message
+    routes: {
+      [p('/ws')]: (req, server) => {
+        const session = sessionFromRequest(req)
+        if (server.upgrade(req, {
+          data: session ? { userId: session.user.user_id, sessionId: session.session_id, displayName: session.user.display_name } : {}
+        })) return
+        return new Response('WebSocket upgrade required', { status: 426 })
+      },
+      [p('/vendor/rdbl.js')]: () => {
+        return new Response(Bun.file(new URL(import.meta.resolve('@devchitchat/rdbljs/src/rdbl.js'))), {
+          headers: { 'Content-Type': 'text/javascript' },
+        })
+      },
+      // Service worker at basePath scope so it can receive push events for all app pages
+      [p('/sw.js')]: () => new Response(
+        Bun.file(import.meta.dir + '/pages/public/sw.js'),
+        { headers: { 'Content-Type': 'application/javascript; charset=utf-8', 'Service-Worker-Allowed': `${basePath}/`, 'Cache-Control': 'no-cache, no-store' } }
+      ),
+      // Dynamic PWA manifest — start_url and icon.src must reflect basePath
+      [p('/manifest.json')]: () => new Response(
+        JSON.stringify({
+          name: 'devchitchat',
+          short_name: 'devchitchat',
+          start_url: `${basePath}/`,
+          scope: `${basePath}/`,
+          display: 'standalone',
+          background_color: '#1a1b1e',
+          theme_color: '#141517',
+          icons: [
+            { src: `${basePath}/icon.png`, sizes: '300x300', type: 'image/png', purpose: 'any maskable' }
+          ]
+        }),
+        { headers: { 'Content-Type': 'application/manifest+json', 'Cache-Control': 'no-cache' } }
+      ),
+    },
+
+    // Bun native WebSocket handler (new index97 passthrough)
+    websocket: chat.websocket,
+    tls: await getTlsIfAvailable(),
+    onShutdown: (server) => {
+      logger.info('server.shutdown', {})
+      server.stop()
+      db.close()
+      process.exit(0)
+    },
+  })
+
+  // Give ChatServer a reference to the Bun server so it can publish to topics
+  chat.attachServer(server)
+
+  logger.info('server.ready', { port: server.port, dev, basePath })
+
+  return server
+}
+
+// Run directly when invoked as CLI / bin
+if (import.meta.main) {
+  await start()
+}

package/migrate/001-drop-channel-invites.js

@@ -0,0 +1,3 @@
+export function run(db) {
+  db.exec(`DROP TABLE IF EXISTS channel_invites`)
+}

package/migrate/002-invite-initial-roles.js

@@ -0,0 +1,5 @@
+export function run(db) {
+  try {
+    db.exec(`ALTER TABLE invites ADD COLUMN initial_roles_json TEXT NOT NULL DEFAULT '["user"]'`)
+  } catch { /* column already exists — initDb creates it on fresh installs */ }
+}

package/migrate/003-dm-channels.js

@@ -0,0 +1,35 @@
+/**
+ * Make channels.hub_id nullable so DM channels (kind = 'dm') can exist
+ * without a hub. SQLite does not support ALTER COLUMN, so we recreate the table.
+ *
+ * Each statement is a separate db.exec() call — bun:sqlite does not reliably
+ * execute all statements in a single multi-statement exec() inside a transaction.
+ */
+export function run(db) {
+  db.exec(`
+    CREATE TABLE channels_new (
+      channel_id         TEXT PRIMARY KEY,
+      hub_id             TEXT,
+      kind               TEXT NOT NULL,
+      name               TEXT NOT NULL,
+      topic              TEXT,
+      visibility         TEXT NOT NULL,
+      sort_order         INTEGER NOT NULL DEFAULT 0,
+      created_by_user_id TEXT NOT NULL,
+      created_at         INTEGER NOT NULL,
+      deleted_at         INTEGER,
+      FOREIGN KEY(created_by_user_id) REFERENCES users(user_id)
+    )
+  `)
+
+  db.exec(`
+    INSERT INTO channels_new
+      SELECT channel_id, hub_id, kind, name, topic, visibility,
+             sort_order, created_by_user_id, created_at, deleted_at
+      FROM channels
+  `)
+
+  db.exec(`DROP TABLE channels`)
+
+  db.exec(`ALTER TABLE channels_new RENAME TO channels`)
+}

package/migrate/004-notifications.js

@@ -0,0 +1,15 @@
+/**
+ * Add mention tracking and message priority to support the notifications system.
+ *
+ * deliveries.mention_seq — seq of the last unread @mention for this user in this channel.
+ *   0 = no pending mention. Cleared when the user's after_seq advances past it.
+ *
+ * messages.priority — sender-chosen urgency: 'normal' | 'async' | 'now'.
+ *   'normal'  → passive catch-up only (default)
+ *   'async'   → subtle sound + queued into reconnect digest
+ *   'now'     → push + sound, bypasses DND
+ */
+export function run(db) {
+  try { db.exec(`ALTER TABLE deliveries ADD COLUMN mention_seq INTEGER NOT NULL DEFAULT 0`) } catch { /* already exists */ }
+  try { db.exec(`ALTER TABLE messages ADD COLUMN priority TEXT NOT NULL DEFAULT 'normal'`) } catch { /* already exists */ }
+}

package/migrate/005-uploads.js

@@ -0,0 +1,21 @@
+export function run(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS uploads (
+      upload_id        TEXT    PRIMARY KEY,
+      uploader_user_id TEXT    NOT NULL REFERENCES users(user_id),
+      channel_id       TEXT    NOT NULL REFERENCES channels(channel_id),
+      msg_id           TEXT    REFERENCES messages(msg_id),
+      original_name    TEXT    NOT NULL,
+      stored_name      TEXT    NOT NULL,
+      mime_type        TEXT    NOT NULL,
+      size_bytes       INTEGER NOT NULL,
+      created_at       INTEGER NOT NULL
+    )
+  `)
+
+  try {
+    db.exec(`ALTER TABLE messages ADD COLUMN attachments_json TEXT`)
+  } catch {
+    // column already exists — idempotent
+  }
+}

package/migrate/006-mention-priority.js

@@ -0,0 +1,3 @@
+export function run(db) {
+  try { db.exec(`ALTER TABLE deliveries ADD COLUMN mention_priority TEXT NOT NULL DEFAULT 'normal'`) } catch { /* already exists */ }
+}

package/migrate/007-push-subscriptions.js

@@ -0,0 +1,14 @@
+export function run(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS push_subscriptions (
+      sub_id       TEXT    PRIMARY KEY,
+      user_id      TEXT    NOT NULL REFERENCES users(user_id) ON DELETE CASCADE,
+      endpoint     TEXT    NOT NULL UNIQUE,
+      p256dh       TEXT    NOT NULL,
+      auth         TEXT    NOT NULL,
+      created_at   INTEGER NOT NULL,
+      last_used_at INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_push_subscriptions_user_id ON push_subscriptions (user_id);
+  `)
+}

package/migrate/008-messages-channel-seq-index.js

@@ -0,0 +1,3 @@
+export function run(db) {
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_messages_channel_seq ON messages (channel_id, seq)`)
+}

package/migrate/009-message-reactions.js

@@ -0,0 +1,15 @@
+export function run(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS message_reactions (
+      reaction_id  TEXT    PRIMARY KEY,
+      msg_id       TEXT    NOT NULL REFERENCES messages(msg_id) ON DELETE CASCADE,
+      channel_id   TEXT    NOT NULL,
+      user_id      TEXT    NOT NULL,
+      emoji        TEXT    NOT NULL,
+      ts           INTEGER NOT NULL,
+      UNIQUE (msg_id, user_id, emoji)
+    );
+    CREATE INDEX IF NOT EXISTS idx_reactions_msg ON message_reactions (msg_id);
+    CREATE INDEX IF NOT EXISTS idx_reactions_channel ON message_reactions (channel_id);
+  `)
+}

package/migrate/010-edit-messages.js

@@ -0,0 +1,7 @@
+export function run(db) {
+  try {
+    db.exec(`ALTER TABLE messages ADD COLUMN edited_at INTEGER`)
+  } catch (e) {
+    if (!e.message.includes('duplicate column name')) throw e
+  }
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@devchitchat/chat",
+  "version": "0.0.0",
+  "description": "A small chat app. p2p video and screenshare.",
+  "scripts": {
+    "dev": "bun --watch index.js",
+    "start": "bun index.js",
+    "migrate": "bun scripts/migrate.js",
+    "test": "bun test",
+    "generate-vapid": "bun scripts/generate-vapid.js",
+    "create-secrets": "kubectl create secret generic chat-web-vapid --from-env-file=.env --namespace=${KUBE_NAMESPACE:-default} --dry-run=client -o yaml | kubectl apply -f -",
+    "docker-build": "./docker-build-k3s.sh",
+    "local-deploy": "kubectl config use-context ${KUBE_CONTEXT:-k3s-local} && kubectl apply -f charts/web/templates/deployment.yaml -n ${KUBE_NAMESPACE:-default}",
+    "backup": "bun scripts/backup.js",
+    "backup-uploads": "bun scripts/backup-uploads.js",
+    "deploy-backup": "kubectl config use-context ${KUBE_CONTEXT:-k3s-local} && helm upgrade --install chat-web charts/web -f charts/web/values.local.yaml -n ${KUBE_NAMESPACE:-default}",
+    "backup-now": "kubectl config use-context ${KUBE_CONTEXT:-k3s-local} && kubectl create job --from=cronjob/chat-backup chat-backup-$(date +%s) -n ${KUBE_NAMESPACE:-default}",
+    "backup-pull": "kubectl config use-context ${KUBE_CONTEXT:-k3s-local} && kubectl cp $(kubectl get pod -l app=chat-web -o jsonpath='{.items[0].metadata.name}' -n ${KUBE_NAMESPACE:-default}):/var/lib/chat/backups ../backups -n ${KUBE_NAMESPACE:-default}",
+    "restore": "bun scripts/restore.js",
+    "restore-uploads": "bun scripts/restore-uploads.js",
+    "push": "bun docker-build && bun local-deploy",
+    "purge-cf-cache": "bun scripts/purge-cf-cache.js"
+  },
+  "type": "module",
+  "bin": {
+    "devchitchat": "index.js"
+  },
+  "files": [
+    "index.js",
+    "src/",
+    "pages/",
+    "migrate/",
+    "styles.css"
+  ],
+  "dependencies": {
+    "@devchitchat/index97": "^2.1.2",
+    "@devchitchat/rdbljs": "^2.0.1"
+  },
+  "main": "index.js",
+  "module": "index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/devchitchat/chat.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/pages/_error.html

@@ -0,0 +1,12 @@
+<!-- pages/_error.html -->
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>{{status}} — {{title}}</title>
+</head>
+<body>
+  <h1>{{status}} — {{title}}</h1>
+  <p>{{message}}</p>
+</body>
+</html>