@devchitchat/chat 3.0.61 → 4.0.1

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.1",
   "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",

package/pages/admin/bots/[userId].js

@@ -1,5 +1,5 @@
 import { requireAdminSession } from '../../../src/adminAuth.js'
-import { botService, channelService } from '../../../src/context.js'
+import { botService, channelService, hubService } from '../../../src/context.js'
 import { randomToken } from '../../../src/util/crypto.js'
 import { p } from '../../../src/config.js'
 
@@ -25,10 +25,34 @@ export function GET(req) {
   if (flashId) tokenFlashes.delete(flashId)
   const flash = url.searchParams.get('flash') ?? null
 
-  // All channels for channel assignment checkboxes
   const allChannels = channelService.listChannels(session.user.user_id, session.user.roles)
+  const allHubs     = hubService.listHubs(session.user.user_id, session.user.roles)
   const botChannelIds = new Set(bot.channels.map(c => c.channel_id))
 
+  // Group channels by hub, preserving hub order; collect channels with no hub separately
+  const hubMap = new Map(allHubs.map(h => [h.hub_id, { ...h, channels: [] }]))
+  const noHubChannels = []
+  for (const ch of allChannels) {
+    const entry = { ...ch, checked: botChannelIds.has(ch.channel_id) }
+    if (ch.hub_id && hubMap.has(ch.hub_id)) {
+      hubMap.get(ch.hub_id).channels.push(entry)
+    } else {
+      noHubChannels.push(entry)
+    }
+  }
+
+  // Compute hub-level checked/indeterminate state for UI rendering
+  const hubGroups = [...hubMap.values()]
+    .filter(h => h.channels.length > 0)
+    .map(h => {
+      const checkedCount = h.channels.filter(c => c.checked).length
+      return {
+        ...h,
+        hubChecked:       checkedCount === h.channels.length,
+        hubIndeterminate: checkedCount > 0 && checkedCount < h.channels.length,
+      }
+    })
+
   return {
     user: session.user,
     pageTitle: `Admin — Bot: ${bot.handle}`,
@@ -37,16 +61,14 @@ export function GET(req) {
     flash,
     tokens: bot.tokens.map(t => ({
       ...t,
-      created_at_fmt: new Date(t.created_at).toLocaleString(),
-      expires_at_fmt: t.expires_at ? new Date(t.expires_at).toLocaleString() : 'Never',
+      created_at_fmt:   new Date(t.created_at).toLocaleString(),
+      expires_at_fmt:   t.expires_at ? new Date(t.expires_at).toLocaleString() : 'Never',
       last_used_at_fmt: t.last_used_at ? new Date(t.last_used_at).toLocaleString() : 'Never',
-      revoked: !!t.revoked_at,
-      expired: !t.revoked_at && t.expires_at != null && t.expires_at <= Date.now(),
-    })),
-    allChannels: allChannels.map(c => ({
-      ...c,
-      checked: botChannelIds.has(c.channel_id),
+      revoked:  !!t.revoked_at,
+      expired:  !t.revoked_at && t.expires_at != null && t.expires_at <= Date.now(),
     })),
+    hubGroups,
+    noHubChannels,
   }
 }
 

package/pages/admin/bots/[userId].phtml

@@ -75,15 +75,88 @@
 
   <section class="admin-section">
     <h2>Channel access</h2>
-    <form method="POST" class="admin-form">
+    <form method="POST" class="admin-form" id="channel-access-form">
       <input type="hidden" name="action" value="set_channels">
-      {{#each allChannels}}
-      <label class="checkbox-label">
-        <input type="checkbox" name="channel_ids" value="{{channel_id}}" {{#if checked}}checked{{/if}}>
-        # {{name}}
-      </label>
+
+      {{#each hubGroups}}
+      <details class="hub-group" {{#if hubChecked}}open{{/if}}{{#if hubIndeterminate}}open{{/if}}>
+        <summary class="hub-group__summary">
+          <input type="checkbox"
+            class="hub-checkbox"
+            data-hub="{{hub_id}}"
+            {{#if hubChecked}}checked{{/if}}
+            {{#if hubIndeterminate}}data-indeterminate="true"{{/if}}>
+          <span class="hub-group__name">{{name}}</span>
+          <span class="hub-group__badge">{{visibility}}</span>
+        </summary>
+        <div class="hub-group__channels">
+          {{#each channels}}
+          <label class="checkbox-label checkbox-label--indented">
+            <input type="checkbox"
+              class="channel-checkbox"
+              name="channel_ids"
+              value="{{channel_id}}"
+              data-hub="{{hub_id}}"
+              {{#if checked}}checked{{/if}}>
+            # {{name}}
+          </label>
+          {{/each}}
+        </div>
+      </details>
       {{/each}}
+
+      {{#if noHubChannels}}
+      <details class="hub-group" open>
+        <summary class="hub-group__summary">
+          <span class="hub-group__name">No hub</span>
+        </summary>
+        <div class="hub-group__channels">
+          {{#each noHubChannels}}
+          <label class="checkbox-label checkbox-label--indented">
+            <input type="checkbox"
+              class="channel-checkbox"
+              name="channel_ids"
+              value="{{channel_id}}"
+              {{#if checked}}checked{{/if}}>
+            # {{name}}
+          </label>
+          {{/each}}
+        </div>
+      </details>
+      {{/if}}
+
       <button type="submit" class="btn">Save channel access</button>
     </form>
   </section>
+
+  <script>
+    // Set indeterminate state (can't be done in HTML, only via JS property)
+    document.querySelectorAll('.hub-checkbox[data-indeterminate="true"]').forEach(cb => {
+      cb.indeterminate = true
+    })
+
+    // Hub checkbox toggles all its channel checkboxes
+    document.querySelectorAll('.hub-checkbox').forEach(hubCb => {
+      hubCb.addEventListener('change', () => {
+        const hubId = hubCb.dataset.hub
+        document.querySelectorAll(`.channel-checkbox[data-hub="${hubId}"]`).forEach(ch => {
+          ch.checked = hubCb.checked
+        })
+        hubCb.indeterminate = false
+      })
+    })
+
+    // Channel checkbox updates its hub checkbox state
+    document.querySelectorAll('.channel-checkbox[data-hub]').forEach(chanCb => {
+      chanCb.addEventListener('change', () => {
+        const hubId = chanCb.dataset.hub
+        const hubCb = document.querySelector(`.hub-checkbox[data-hub="${hubId}"]`)
+        if (!hubCb) return
+        const siblings = [...document.querySelectorAll(`.channel-checkbox[data-hub="${hubId}"]`)]
+        const checkedCount = siblings.filter(c => c.checked).length
+        hubCb.checked = checkedCount === siblings.length
+        hubCb.indeterminate = checkedCount > 0 && checkedCount < siblings.length
+      })
+    })
+  </script>
 </div>

package/pages/public/themes/base.css

@@ -1484,6 +1484,64 @@ body:has(.admin-topbar) main {
   cursor: pointer;
 }
 
+.checkbox-label--indented {
+  padding-left: 24px;
+}
+
+.hub-group {
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  margin-bottom: 8px;
+  overflow: hidden;
+}
+
+.hub-group__summary {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 8px 12px;
+  background: var(--bg-secondary);
+  cursor: pointer;
+  font-size: 14px;
+  font-weight: 500;
+  list-style: none;
+  user-select: none;
+}
+
+.hub-group__summary::-webkit-details-marker { display: none; }
+
+.hub-group__summary::before {
+  content: '▶';
+  font-size: 10px;
+  color: var(--text-muted);
+  transition: transform 0.15s;
+  flex-shrink: 0;
+}
+
+details.hub-group[open] > .hub-group__summary::before {
+  transform: rotate(90deg);
+}
+
+.hub-group__name {
+  flex: 1;
+}
+
+.hub-group__badge {
+  font-size: 11px;
+  font-weight: normal;
+  color: var(--text-muted);
+  background: var(--bg-input);
+  padding: 2px 6px;
+  border-radius: 10px;
+}
+
+.hub-group__channels {
+  padding: 8px 12px;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
 .token-display {
   display: inline-block;
   margin-top: 8px;

package/src/adapters/SqliteChannelRepository.js

@@ -49,6 +49,18 @@ export class SqliteChannelRepository {
     ).all()
   }
 
+  listMemberships({ userId }) {
+    return this.db.prepare(
+      `SELECT c.channel_id, c.hub_id, c.name, c.kind, c.visibility, c.topic, c.sort_order, h.name AS hub_name
+       FROM channels c
+       JOIN hubs h ON c.hub_id = h.hub_id
+       JOIN channel_members cm ON cm.channel_id = c.channel_id
+       WHERE c.deleted_at IS NULL AND h.deleted_at IS NULL
+         AND cm.user_id = ? AND cm.left_at IS NULL AND cm.banned_at IS NULL
+       ORDER BY h.name, c.sort_order ASC, c.created_at ASC`
+    ).all(userId)
+  }
+
   listAccessible({ userId, isGuest = false }) {
     return this.db.prepare(
       `SELECT c.channel_id, c.hub_id, c.name, c.kind, c.visibility, c.topic, c.sort_order, h.name AS hub_name

package/src/services/BotService.js

@@ -11,10 +11,11 @@ import { randomToken, hashToken } from '../util/crypto.js'
 import { ServiceError } from '../util/errors.js'
 
 export class BotService {
-  constructor({ authService, authRepo, channelRepo, nowFn = () => Date.now() }) {
+  constructor({ authService, authRepo, channelRepo, hubService, nowFn = () => Date.now() }) {
     this.authService = authService
     this.authRepo = authRepo
     this.channelRepo = channelRepo
+    this.hubService = hubService
     this.nowFn = nowFn
   }
 
@@ -119,10 +120,22 @@ export class BotService {
     for (const channelId of toLeave) {
       this.channelRepo.setMemberLeft({ channelId, userId, now })
     }
+
+    // Ensure hub membership for every channel in the final set.
+    // Done after the membership loop so it covers both new and pre-existing
+    // channel memberships (upsert is idempotent so re-running is safe).
+    const hubIds = new Set()
+    for (const channelId of next) {
+      const channel = this.channelRepo.findById({ channelId })
+      if (channel?.hub_id) hubIds.add(channel.hub_id)
+    }
+    for (const hubId of hubIds) {
+      this.hubService.joinHub(hubId, userId)
+    }
   }
 
   _getBotChannels(userId) {
-    return this.channelRepo.listAccessible({ userId })
+    return this.channelRepo.listMemberships({ userId })
   }
 
   // ── Internals ──────────────────────────────────────────────────────────────

package/src/ws/ChatServer.js

@@ -77,7 +77,7 @@ export class ChatServer {
     this.notificationService = new NotificationService({ deliveryService: this.deliveryService, authService: this.auth })
     this.presenceService  = new PresenceService()
     this.signalingService = new SignalingService({ signalingRepo: new SqliteSignalingRepository({ db }) })
-    this.botService       = new BotService({ authService: this.auth, authRepo, channelRepo })
+    this.botService       = new BotService({ authService: this.auth, authRepo, channelRepo, hubService: this.hubService })
     this.pushService      = new WebPushService({
       vapidPublicKey:  process.env.VAPID_PUBLIC_KEY  ?? null,
       vapidPrivateKey: process.env.VAPID_PRIVATE_KEY ?? null,
@@ -323,8 +323,12 @@ export class ChatServer {
         })
         .filter(Boolean)
     } else {
+      const memberIds = new Set(
+        this.channelService.listChannelMembers(channelId).map(m => m.user_id)
+      )
       candidates = this.auth.listUsersBasic()
-        .filter(u => u.user_id !== senderId && !u.roles.includes('bot'))
+        .filter(u => u.user_id !== senderId)
+        .filter(u => !u.roles.includes('bot') || memberIds.has(u.user_id))
         .map(u => ({ user_id: u.user_id, handle: u.handle }))
     }
 
@@ -337,7 +341,6 @@ export class ChatServer {
       }))
       if (priority === 'now' && this.pushService.isConfigured()) {
         const sender   = this.auth.getUser(senderId)
-        const channel  = this.channelService.getChannel(channelId)
         this.pushService.sendToUser({
           userId:    user_id,
           title:     `@${sender?.handle ?? 'someone'} mentioned you`,