@devchitchat/chat 3.0.61 → 4.0.0

package/README.md

@@ -30,11 +30,74 @@ The system should just create a default hub and channel. That way, on bootstrap,
 
 # Getting Started
 
-## Prerequisites
+## Install as a package
+
+```bash
+bun add @devchitchat/chat
+```
+
+Then start it from your own server file:
+
+```js
+// server.mjs
+import { start } from '@devchitchat/chat'
+
+const server = await start({
+  port: 3000,
+  basePath: '/chat',       // mount at example.com/chat — omit for root
+  dbPath: './data/chat.db',
+})
+
+console.log(`chat listening on port ${server.port}`)
+```
+
+All config options and their defaults:
+
+| Option | Env var fallback | Default |
+|---|---|---|
+| `port` | `PORT` | `3000` |
+| `dbPath` | `DB_PATH` | `./data/chat.db` |
+| `basePath` | `BASE_PATH` | `""` (root) |
+| `dev` | `NODE_ENV !== 'production'` | `true` |
+| `tlsCert` | `TLS_CERT` | `./certs/dev-cert.pem` |
+| `tlsKey` | `TLS_KEY` | `./certs/dev-key.pem` |
+
+Every option falls back to its environment variable, so you can configure via env instead of passing a config object:
+
+```bash
+BASE_PATH=/chat PORT=3000 DB_PATH=./data/chat.db bun server.mjs
+```
+
+`start()` returns the [Bun server instance](https://bun.sh/docs/api/http#bun-serve) — you can inspect `server.port`, stop it with `server.stop()`, etc.
+
+Migrations run automatically on every call to `start()` — no separate migration step needed.
+
+---
+
+## Run standalone
+
+To run the chat app directly without writing a wrapper:
+
+```bash
+bunx devchitchat
+```
+
+Or install globally:
+
+```bash
+bun install -g @devchitchat/chat
+devchitchat
+```
+
+---
+
+## Run from source
+
+### Prerequisites
 
 - [Bun](https://bun.sh) v1.0 or later
 
-## Install
+### Install
 
 ```bash
 bun install
@@ -121,6 +184,7 @@ Copy that URL and open it in a browser to create the first account, which become
 |---|---|---|
 | `PORT` | `3000` | Port the server listens on |
 | `DB_PATH` | `data/chat.db` | Path to the SQLite database file |
+| `BASE_PATH` | `""` | URL subpath to mount the app at (e.g. `/chat`) |
 | `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 |

package/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { createServer } from '@devchitchat/index97'
+import { createServer, createRoutes } from '@devchitchat/index97'
 import { openDatabase } from './src/db/openDb.js'
 import { initDb } from './src/db/initDb.js'
 import { runMigrations } from './src/db/runMigrations.js'
@@ -12,26 +12,16 @@ 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 CHAT_PAGES_DIR = import.meta.dir + '/pages'
+const CHAT_PUBLIC_DIR = CHAT_PAGES_DIR + '/public'
+const CHAT_CSP = "default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; connect-src 'self' ws: wss:"
+const CHAT_PERMISSIONS_POLICY = 'camera=(self), microphone=(self), display-capture=(self)'
+
+async function _setupServices(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}`
@@ -50,7 +40,6 @@ export async function start(config = {}) {
   })
   chat.messageService.setUploadService(uploadService)
 
-  // Wire service context so page handlers (pages/**/*.js) can access services
   initContext({
     auth: chat.auth,
     hubService: chat.hubService,
@@ -67,26 +56,133 @@ export async function start(config = {}) {
     logger,
   })
 
+  return { chat, db, logger, p, basePath, dev }
+}
+
+/**
+ * Return chat routes and websocket handler for embedding in an existing server.
+ *
+ * Use this when you want to run the chat app on the same port as another app.
+ * Pass the returned routes and websocket to your own createServer() call, then
+ * call onServerReady() with the server instance once it is created.
+ *
+ * @example
+ * import { createServer } from '@devchitchat/index97'
+ * import { setup as setupChat } from '@devchitchat/chat'
+ *
+ * const chat = await setupChat({ basePath: '/chat', dbPath: './data/chat.db' })
+ *
+ * const server = await createServer({
+ *   pagesDir: new URL('./pages', import.meta.url).pathname,
+ *   port: 3000,
+ *   routes: chat.routes,
+ *   websocket: chat.websocket,
+ * })
+ *
+ * chat.onServerReady(server)
+ *
+ * @param {object} config
+ * @param {string}  [config.basePath]  - URL prefix for all chat routes (e.g. '/chat')
+ * @param {string}  [config.dbPath]    - Path to the SQLite database file
+ * @param {boolean} [config.dev]       - Enable dev mode
+ * @returns {Promise<{ routes: object, websocket: object, onServerReady: Function }>}
+ */
+export async function setup(config = {}) {
+  const { chat, logger, p, basePath, dev } = await _setupServices(config)
+
+  // Discover and prefix all file-based chat page routes
+  const routes = await createRoutes({
+    pagesDir: CHAT_PAGES_DIR,
+    prefix: basePath,
+    dev,
+    csp: CHAT_CSP,
+    permissionsPolicy: CHAT_PERMISSIONS_POLICY,
+  })
+
+  // Explicit protocol routes
+  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 })
+  }
+
+  routes[p('/vendor/rdbl.js')] = () =>
+    new Response(Bun.file(new URL(import.meta.resolve('@devchitchat/rdbljs/src/rdbl.js'))), {
+      headers: { 'Content-Type': 'text/javascript' },
+    })
+
+  routes[p('/sw.js')] = () => new Response(
+    Bun.file(CHAT_PAGES_DIR + '/public/sw.js'),
+    { headers: { 'Content-Type': 'application/javascript; charset=utf-8', 'Service-Worker-Allowed': `${basePath}/`, 'Cache-Control': 'no-cache, no-store' } }
+  )
+
+  routes[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' } }
+  )
+
+  // Static files from pages/public/ — register each as an explicit route so the
+  // host server's fetch handler (which only knows its own public dir) can serve them
+  const glob = new Bun.Glob('**/*')
+  for await (const file of glob.scan({ cwd: CHAT_PUBLIC_DIR, onlyFiles: true })) {
+    if (file === '.DS_Store') continue
+    const pattern = basePath + '/' + file
+    const filePath = CHAT_PUBLIC_DIR + '/' + file
+    routes[pattern] = () => new Response(Bun.file(filePath))
+  }
+
+  return {
+    routes,
+    websocket: chat.websocket,
+    onServerReady(server) {
+      chat.attachServer(server)
+      logger.info('server.ready', { basePath })
+    },
+  }
+}
+
+/**
+ * Start the devchitchat server as a standalone process.
+ *
+ * @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),
+    tlsCert = process.env.TLS_CERT ?? './certs/dev-cert.pem',
+    tlsKey = process.env.TLS_KEY ?? './certs/dev-key.pem',
+  } = config
+
+  const { chat, db, logger, p, basePath, dev } = await _setupServices(config)
+
   async function getTlsIfAvailable() {
     const cert = Bun.file(tlsCert)
-    if (await cert.exists()) {
-      return { cert, key: Bun.file(tlsKey) }
-    }
+    if (await cert.exists()) return { cert, key: Bun.file(tlsKey) }
     return null
   }
 
   const server = await createServer({
-    pagesDir: import.meta.dir + '/pages',
+    pagesDir: CHAT_PAGES_DIR,
     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.
+    permissionsPolicy: CHAT_PERMISSIONS_POLICY,
+    csp: CHAT_CSP,
     idleTimeout: 0,
-    // WebSocket upgrade route — authenticate via session cookie before the first message
     routes: {
       [p('/ws')]: (req, server) => {
         const session = sessionFromRequest(req)
@@ -95,35 +191,24 @@ export async function start(config = {}) {
         })) 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'))), {
+      [p('/vendor/rdbl.js')]: () =>
+        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'),
+        Bun.file(CHAT_PAGES_DIR + '/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' }
-          ]
+          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) => {
@@ -134,11 +219,8 @@ export async function start(config = {}) {
     },
   })
 
-  // 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
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devchitchat/chat",
-  "version": "3.0.61",
+  "version": "4.0.0",
   "description": "A small chat app. p2p video and screenshare.",
   "scripts": {
     "dev": "bun --watch index.js",
@@ -33,7 +33,7 @@
     "styles.css"
   ],
   "dependencies": {
-    "@devchitchat/index97": "^2.1.2",
+    "@devchitchat/index97": "^3.0.0",
     "@devchitchat/rdbljs": "^2.0.1"
   },
   "main": "index.js",