switchboard/core
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Releases 9 Wiki Activity

Changeset 0.20.0 (#85)

Browse Source
This commit is contained in:
xcaliber
2026-03-01 12:40:15 +00:00
parent eb74180611
commit 817062e5fc
57 changed files with 5435 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.gitea/workflows/ci.yaml
View File

@@ -403,6 +403,7 @@ jobs:
if [[ "${{ gitea.event_name }}" == "pull_request" ]]; then
echo "ENVIRONMENT=dev" >> "$GITHUB_OUTPUT"
echo "GIN_MODE=debug" >> "$GITHUB_OUTPUT"
echo "IMAGE_TAG=dev" >> "$GITHUB_OUTPUT"
echo "BASE_PATH=/dev" >> "$GITHUB_OUTPUT"
echo "DEPLOY_SUFFIX=-dev" >> "$GITHUB_OUTPUT"
@@ -422,6 +423,7 @@ jobs:
elif [[ "${{ gitea.ref }}" == refs/tags/v* ]]; then
VERSION="${{ gitea.ref_name }}"
echo "ENVIRONMENT=production" >> "$GITHUB_OUTPUT"
echo "GIN_MODE=release" >> "$GITHUB_OUTPUT"
echo "IMAGE_TAG=latest" >> "$GITHUB_OUTPUT"
echo "EXTRA_TAG=${VERSION}" >> "$GITHUB_OUTPUT"
echo "BASE_PATH=" >> "$GITHUB_OUTPUT"
@@ -442,6 +444,7 @@ jobs:
echo "env_label=production (${VERSION})" >> "$GITHUB_OUTPUT"
else
echo "ENVIRONMENT=test" >> "$GITHUB_OUTPUT"
echo "GIN_MODE=debug" >> "$GITHUB_OUTPUT"
echo "IMAGE_TAG=test" >> "$GITHUB_OUTPUT"
echo "BASE_PATH=/test" >> "$GITHUB_OUTPUT"
echo "DEPLOY_SUFFIX=-test" >> "$GITHUB_OUTPUT"
@@ -677,6 +680,7 @@ jobs:
- name: Render and apply manifests
env:
ENVIRONMENT: ${{ steps.env.outputs.ENVIRONMENT }}
GIN_MODE: ${{ steps.env.outputs.GIN_MODE }}
IMAGE_TAG: ${{ steps.env.outputs.IMAGE_TAG }}
DEPLOY_SUFFIX: ${{ steps.env.outputs.DEPLOY_SUFFIX }}
DEPLOY_HOST: ${{ steps.env.outputs.DEPLOY_HOST }}

11
CHANGELOG.md
View File

@@ -2,6 +2,17 @@
All notable changes to Chat Switchboard.
## [0.20.0] — 2026-03-01
### Added
- **Notifications Core (Phase 1)**: Persistent, user-targeted notification infrastructure with real-time WebSocket delivery. `notifications` table (Postgres + SQLite), `NotificationStore` with paginated queries, `Service.Notify()` / `NotifyMany()` for centralized creation and dispatch. Five API endpoints: list (paginated, filterable), unread count, mark read, mark all read, delete. Bell icon in header bar with unread count badge (capped at 9+). Notification dropdown (latest 10, grouped, click-to-navigate via `resource_type`/`resource_id`). Full notification panel registered with `PanelRegistry`. WebSocket push via `notification.new` event with toast for high-priority types (`kb.error`, `role.fallback`). Background cleanup goroutine (configurable retention, default 90 days). Initial sources: `role.fallback` (via EventBus subscription), `kb.ready`/`kb.error` (knowledge base processing), `grant.changed` (group membership).
- **@mention Parsing + Multi-model Routing (Phase 2)**: Channels support multiple AI models with @mention-based routing. `mentions.Parse()` extracts @mentions from message content, resolves against channel model roster (case-insensitive, longest-match-first, trailing punctuation tolerant). Completion handler fans out sequentially to mentioned model(s), producing one assistant response per target. Without @mention, default channel model responds (fully backward compatible). Channel model CRUD: 4 new endpoints for add/remove/update/list. Frontend: model pills in chat header, @mention autocomplete (CM6 `mentionCompletion` extension with roster-backed suggestions), model attribution labels on multi-model responses. Message `model_display` field for human-readable attribution. SSE streaming tagged with model info per response.
- **Email Transport + Notification Preferences (Phase 3)**: SMTP email delivery via `EmailTransport` supporting implicit TLS (port 465) and STARTTLS (port 587). Multipart MIME messages (HTML + plaintext) with branded templates using Go `html/template`. `notification_preferences` table with three-tier resolution: specific type → user wildcard `*` → system default (in_app=true, email=false). Three preference API endpoints (list, set with partial patch, delete). Admin SMTP configuration in settings (host, port, user, password, from address, TLS mode) with test email endpoint. User notification preferences UI in Settings → Notifications tab with per-type in-app/email checkboxes. Async email delivery (goroutine with 30s timeout, failures logged non-blocking).
- **Gin Release Mode**: Backend now automatically sets `gin.SetMode(gin.ReleaseMode)` when `ENVIRONMENT=production`, suppressing per-request access logs for health checks and reducing log noise. `GIN_MODE` env var also added to K8s backend deployment as explicit override.
### Fixed
- **Model preferences 500 on every page load**: `GET /api/v1/models/preferences` returned HTTP 500 due to `NULL` values in `user_model_settings.hidden` and `sort_order` columns failing Go `sql.Scan()` into non-pointer types. Root cause: the `Set` upsert passed `NULL` for unset patch fields, bypassing `DEFAULT false`/`DEFAULT 0` on INSERT. Fixed with `COALESCE` in both SELECT (read path) and INSERT VALUES (write path) for Postgres and SQLite. Includes data-fix SQL for existing NULL rows.
## [0.19.2] — 2026-02-28
### Added

4
README.md
View File

@@ -30,6 +30,8 @@ docker compose up -d
- **Airgapped**: Local vendor files (marked.js, DOMPurify, KaTeX, mermaid.js), no CDN required
- **Mobile**: Responsive design, PWA manifest
- **Real-time**: WebSocket event bus for tool bridge, live updates
- **Notifications**: In-app notification bell with unread badge, per-type email delivery (SMTP), user preference controls, admin SMTP configuration
- **Multi-model**: @mention routing for multiple AI models per channel, fan-out completions, model attribution
## Architecture
@@ -77,6 +79,8 @@ All configuration via environment variables. See `server/.env.example` for the f
| `SWITCHBOARD_ADMIN_PASSWORD` | ` ` | Bootstrap admin password |
| `ENCRYPTION_KEY` | ` ` | AES key for API key encryption (required if encrypted keys exist) |
| `SEED_USERS` | ` ` | Dev/test only: `user:pass:role,user2:pass2:role2` |
| `ENVIRONMENT` | `development` | Environment name: `development`, `test`, or `production`. Auto-sets Gin release mode in production. |
| `GIN_MODE` | (auto) | Gin framework mode: `debug`, `test`, or `release`. Auto-derived from `ENVIRONMENT` if not set. |
| `STORAGE_BACKEND` | (auto) | `pvc` or `s3`. Auto-detects PVC if not set. |
| `STORAGE_PATH` | `/data/storage` | PVC mount point (also scratch dir for S3 extraction) |
| `S3_ENDPOINT` | ` ` | S3 endpoint (e.g. `http://minio:9000`, required for S3) |

2
VERSION
View File

@@ -1 +1 @@
0.19.2
0.20.0

55
docs/ARCHITECTURE.md
View File

@@ -1,4 +1,4 @@
# Architecture — Chat Switchboard v0.17
# Architecture — Chat Switchboard v0.20
## Deployment Modes
@@ -126,7 +126,7 @@ server/
│ └── 002_v017_persona_kb.sql
├── store/
│ ├── interfaces.go # Store interfaces + shared types
│ ├── postgres/ # Postgres implementations (20 stores)
│ ├── postgres/ # Postgres implementations (22 stores)
│ │ ├── stores.go # NewStores() constructor
│ │ ├── provider.go # ProviderStore
│ │ ├── catalog.go # CatalogStore
@@ -140,7 +140,7 @@ server/
│ │ ├── memory.go # MemoryStore (CRUD + recall)
│ │ ├── memory_hybrid.go # RecallHybrid (pgvector cosine)
│ │ └── ...
│ └── sqlite/ # SQLite implementations (20 stores)
│ └── sqlite/ # SQLite implementations (22 stores)
│ ├── stores.go # NewStores() constructor
│ └── ... # Mirror of postgres/ with dialect adaptations
├── models/models.go # Shared domain types
@@ -154,6 +154,12 @@ server/
├── memory/ # Long-term memory extraction + scanning
│ ├── extractor.go # Conversation analysis → fact extraction
│ └── scanner.go # Background job: find channels needing extraction
├── mentions/ # @mention parsing for multi-model routing
│ └── parser.go # Parse() extracts + resolves @mentions against roster
├── notifications/ # Notification service + email transport
│ ├── service.go # Notify/NotifyMany, preference resolution, dispatch
│ ├── email.go # SMTP transport (TLS/STARTTLS, multipart MIME)
│ └── templates.go # HTML + plaintext email templates
├── handlers/ # HTTP handlers (Gin)
│ ├── auth.go # Login, register, refresh, logout
│ ├── admin.go # User/config/model management
@@ -169,6 +175,10 @@ server/
│ ├── knowledge.go # Knowledge base management
│ ├── memory.go # Memory CRUD + review (user + admin)
│ ├── memory_inject.go # BuildMemoryHint() for completion injection
│ ├── notifications.go # Notification CRUD + preference endpoints
│ ├── admin_email.go # Admin SMTP test email endpoint
│ ├── channel_models.go # Channel model roster CRUD (multi-model)
│ ├── model_prefs.go # User model visibility preferences
│ └── ...
├── notelinks/ # Wikilink extraction (regex → NoteLink structs)
├── knowledge/ # KB chunking, embedding, search
@@ -273,6 +283,45 @@ Migrations are handled by the backend on startup (no separate migration job):
Postgres uses consolidated schemas (`001_v016_schema.sql` + incremental). SQLite uses application-generated UUIDs and `datetime()` instead of `gen_random_uuid()` and `now()`. Both drivers share the same migration tracking table.
## Notifications (v0.20.0)
Centralized notification infrastructure with real-time WebSocket delivery
and optional email transport.
**Service Pattern:** All notification sources go through `notifications.Service`,
never insert directly. `Notify()` persists to store, checks user preferences,
pushes via WebSocket (if online), and dispatches email (if configured and
opted-in). `NotifyMany()` fans out to multiple users (best-effort).
**Preference Resolution:**
```
Specific type pref → User wildcard '*' pref → System default (in_app=true, email=false)
```
**Email Transport:** Optional SMTP via `EmailTransport`. Supports implicit TLS
(port 465) and STARTTLS (port 587). Multipart MIME (HTML + plaintext).
Templates rendered via Go `html/template` with instance branding. Async
delivery via goroutine (failures logged, never block notification creation).
Admin configures SMTP in platform settings; users toggle per-type delivery
in Settings → Notifications.
**Cleanup:** Background goroutine deletes notifications older than retention
period (default 90 days, configurable via admin settings).
## @mention Routing + Multi-model (v0.20.0)
Channels support multiple AI models. The `channel_models` table (schema 001)
holds the roster; `mentions.Parse()` extracts @mentions from message content
and resolves against display names (case-insensitive, longest-match-first).
**Completion Fan-out:** When mentions resolve to channel models, the completion
handler fires sequentially for each target, producing one assistant message
per model. Without @mention, the default channel model responds (backward
compatible). Frontend renders model attribution labels on multi-model responses.
**Autocomplete:** CM6 `mentionCompletion` extension triggers on `@` in the
chat input, showing a dropdown of channel model display names.
## Frontend Architecture
Vanilla JavaScript, no framework. The frontend ships as static files served by nginx. The only build step is the CM6 editor bundle, compiled at Docker build time via esbuild (IIFE output, no runtime bundler).

713
docs/DESIGN-0.20.0.md Normal file
View File

@@ -0,0 +1,713 @@
# DESIGN-0.20.0 — Notifications + @mention Routing + Multi-model
**Status:** Complete (Phases 1–3 delivered 2026-03-01)
**Depends on:** v0.19.2 (Projects complete), EventBus + WebSocket hub (v0.9.x), `channel_models` table (v0.16.0 schema)
**Prerequisite for:** v0.23.0 (Multi-Participant Channels — notifications become the backbone for participant events)
---
## Overview
v0.20.0 delivers two complementary features:
1. **Notifications** — Persistent, user-targeted notification infrastructure with real-time WebSocket push and optional email transport. This is the event backbone for all future collaboration features (multi-participant channels, workflow assignment queues, presence).
2. **@mention Routing + Multi-model** — Channels can host multiple AI models. Users @mention a model (or user, for future multi-participant) to direct a message. The completion handler fans out to the addressed model(s). This builds on the existing `channel_models` table and `ChannelModel` store methods that have been in the schema since v0.16.0 but were never surfaced in UI.
---
## Phasing
| Phase | Scope | Migration | Est. Effort |
|-------|-------|-----------|-------------|
| **1** | Notifications core (in-app) | `007_v0200_notifications.sql` | Medium-large |
| **2** | @mention parsing + multi-model routing | None (uses existing `channel_models`) | Medium |
| **3** | Email transport + user notification preferences | `008_v0200_notification_prefs.sql` | Medium |
Each phase is a merge-ready deliverable. Phase 1 is the critical path — 2 and 3 can be reordered or deferred if needed.
---
## Phase 1 — Notifications Core (in-app)
### Data Model
```sql
-- Postgres: 007_v0200_notifications.sql
CREATE TABLE IF NOT EXISTS notifications (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
type VARCHAR(50) NOT NULL, -- e.g. 'role.fallback', 'kb.processing', 'grant.changed', 'project.invite'
title VARCHAR(255) NOT NULL,
body TEXT DEFAULT '',
resource_type VARCHAR(50), -- 'channel', 'knowledge_base', 'project', 'team', etc.
resource_id UUID, -- nullable — links notification to a navigable entity
is_read BOOLEAN DEFAULT false,
created_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE INDEX idx_notifications_user_unread ON notifications(user_id, is_read, created_at DESC);
CREATE INDEX idx_notifications_user_created ON notifications(user_id, created_at DESC);
```
```sql
-- SQLite: 006_v0200_notifications.sql
CREATE TABLE IF NOT EXISTS notifications (
id TEXT PRIMARY KEY,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
type TEXT NOT NULL,
title TEXT NOT NULL,
body TEXT DEFAULT '',
resource_type TEXT,
resource_id TEXT,
is_read INTEGER DEFAULT 0,
created_at TEXT DEFAULT (datetime('now'))
);
CREATE INDEX IF NOT EXISTS idx_notifications_user_unread ON notifications(user_id, is_read, created_at DESC);
CREATE INDEX IF NOT EXISTS idx_notifications_user_created ON notifications(user_id, created_at DESC);
```
**Design notes:**
- No `updated_at` — notifications are immutable once created (only `is_read` flips).
- `type` is a free-form string, not an enum. New notification sources don't require migration. Convention: `domain.action` (e.g. `role.fallback`, `kb.ready`, `grant.added`, `project.invite`).
- `resource_type` + `resource_id` enable click-to-navigate. Frontend maps these to routes (e.g. `resource_type=channel` → `selectChat(resource_id)`).
- No FK on `resource_id` — the referenced entity may be deleted; notification persists as historical record.
### Store Interface
```go
// server/store/interfaces.go — addition to Stores
type NotificationStore interface {
Create(ctx context.Context, n *models.Notification) error
ListByUser(ctx context.Context, userID string, limit, offset int, unreadOnly bool) ([]models.Notification, int, error) // returns items + total count
MarkRead(ctx context.Context, id, userID string) error
MarkAllRead(ctx context.Context, userID string) error
Delete(ctx context.Context, id, userID string) error
UnreadCount(ctx context.Context, userID string) (int, error)
}
```
Both Postgres and SQLite implementations follow the established pattern. `ListByUser` returns paginated results with a total count for the unread badge. The `userID` parameter on `MarkRead`/`Delete` prevents cross-user access.
### Model
```go
// server/models/models_notification.go
type Notification struct {
ID string `json:"id" db:"id"`
UserID string `json:"user_id" db:"user_id"`
Type string `json:"type" db:"type"`
Title string `json:"title" db:"title"`
Body string `json:"body" db:"body"`
ResourceType string `json:"resource_type,omitempty" db:"resource_type"`
ResourceID string `json:"resource_id,omitempty" db:"resource_id"`
IsRead bool `json:"is_read" db:"is_read"`
CreatedAt time.Time `json:"created_at" db:"created_at"`
}
```
### API Endpoints
```
GET /api/v1/notifications — list (paginated, ?unread_only=true, ?limit=20&offset=0)
GET /api/v1/notifications/unread-count — { "count": 5 }
PATCH /api/v1/notifications/:id/read — mark single read
POST /api/v1/notifications/mark-all-read — mark all read for user
DELETE /api/v1/notifications/:id — delete single
```
All endpoints are user-scoped (auth middleware injects `user_id`). No admin override — notifications are personal.
### Notification Service
Centralized creation + dispatch. All notification sources go through this service, never insert directly.
```go
// server/notifications/service.go
type Service struct {
store store.NotificationStore
hub *events.Hub
}
func (s *Service) Notify(ctx context.Context, n *models.Notification) error {
// 1. Persist
if err := s.store.Create(ctx, n); err != nil {
return err
}
// 2. Real-time push via WebSocket (if user is online)
s.hub.SendToUser(n.UserID, events.Event{
Label: "notification.new",
Payload: events.MustJSON(n),
Ts: time.Now().UnixMilli(),
})
return nil
}
// NotifyMany fans out to multiple users (e.g. team-wide grant change).
func (s *Service) NotifyMany(ctx context.Context, userIDs []string, template models.Notification) error {
for _, uid := range userIDs {
n := template
n.ID = store.NewID()
n.UserID = uid
_ = s.Notify(ctx, &n) // best-effort; log errors, don't fail batch
}
return nil
}
```
### EventBus Route Table Addition
```go
// server/events/types.go — add to routeTable
"notification.new": DirToClient, // targeted via Hub.SendToUser, not room-based
"notification.read": DirToClient, // badge sync across tabs
```
### Initial Notification Sources
Wire these into existing code paths. Each source creates a `Notification` via `Service.Notify()`:
| Source | Type | Trigger Point | Title Template |
|--------|------|---------------|----------------|
| Role fallback | `role.fallback` | `capabilities/resolver.go` (already emits EventBus) | "Model fallback: {primary} → {fallback}" |
| KB processing complete | `kb.ready` | `knowledge_bases.go` → after indexing pipeline | "Knowledge base '{name}' ready ({n} chunks)" |
| KB processing error | `kb.error` | `knowledge_bases.go` → on embedding/chunking failure | "Knowledge base '{name}' indexing failed" |
| Group membership changed | `grant.changed` | `groups.go` → AddMember / RemoveMember | "You were added to group '{name}'" |
| Project invite | `project.invite` | Future (v0.23.0+) — stub the type now | — |
**Implementation order:** `role.fallback` first (already emits an EventBus event — just subscribe in notification service), then `kb.ready`/`kb.error` (high user value), then `grant.changed`.
### Frontend — Notification UI
**Bell icon** (header bar, right of model selector):
```
┌─────────────────────────────────────────────────┐
│ ☰ Chat Switchboard [model ▾] 🔔③ 👤 Jeff │
└─────────────────────────────────────────────────┘
```
- `🔔` with `.notification-badge` (red circle, count) when `unreadCount > 0`.
- Badge shows count capped at `9+`.
- On click: toggle notification dropdown.
**Notification dropdown:**
```
┌──────────────────────────────────────┐
│ Notifications Mark all ✓ │
├──────────────────────────────────────┤
│ ● KB "Sales Docs" ready (3 chunks) │
│ 2 minutes ago │
├──────────────────────────────────────┤
│ ○ Model fallback: gpt-4 → gpt-3.5 │
│ 1 hour ago │
├──────────────────────────────────────┤
│ ○ Added to group "Engineering" │
│ Yesterday │
├──────────────────────────────────────┤
│ View all → │
└──────────────────────────────────────┘
```
- `●` = unread, `○` = read. Unread items have subtle background highlight.
- Click item: mark read + navigate to `resource_type`/`resource_id` (open chat, open KB in admin, etc.).
- "Mark all ✓" → `POST /notifications/mark-all-read` → clear badge.
- "View all →" opens full notification list in side panel (registered with `PanelRegistry`, same pattern as Notes/Preview/Project).
- Dropdown max-height: 400px, scrollable. Shows latest 10 items.
- Click-outside / Escape to close.
**File:** `src/js/notifications.js` (new module, ~300-400 lines)
**WebSocket handler:**
```javascript
Events.on('notification.new', (payload) => {
App.notifications.unshift(payload);
App.unreadNotificationCount++;
renderNotificationBadge();
// Optional: toast for high-priority notification types
if (['kb.error', 'role.fallback'].includes(payload.type)) {
UI.toast(payload.title, 'warning');
}
});
```
**Startup:** `GET /notifications/unread-count` on app init → set badge. Lazy-load full list on first dropdown open.
### Files Changed (Phase 1)
**New files:**
- `server/notifications/service.go` — notification service
- `server/handlers/notifications.go` — API handlers
- `server/store/postgres/notification.go` — Postgres store
- `server/store/sqlite/notification.go` — SQLite store
- `server/models/models_notification.go` — model struct
- `server/database/migrations/007_v0200_notifications.sql` — Postgres migration
- `server/database/migrations/sqlite/006_v0200_notifications.sql` — SQLite migration
- `src/js/notifications.js` — frontend notification UI
**Modified files:**
- `server/store/interfaces.go` — add `NotificationStore` to `Stores`
- `server/events/types.go` — add `notification.*` routes
- `server/main.go` (or `server/routes.go`) — wire notification handler + service
- `server/handlers/knowledge_bases.go` — emit `kb.ready` / `kb.error` notifications
- `server/handlers/groups.go` — emit `grant.changed` notifications
- `server/capabilities/resolver.go` — emit `role.fallback` notification (subscribe to existing EventBus event)
- `src/js/app.js` — init notification module, add bell to header
- `src/js/events.js` — add `notification.*` to known labels (documentation only, wildcard already works)
- `src/css/style.css` — notification badge, dropdown, panel styles
- `index.html` — notification bell element in header
- Integration tests — notification CRUD + WebSocket delivery
### Checklist (Phase 1)
- [x] Migration: `notifications` table (Postgres + SQLite)
- [x] Model: `Notification` struct
- [x] Store: `NotificationStore` interface + both implementations
- [x] Service: `notifications.Service` with `Notify()` / `NotifyMany()`
- [x] Handlers: 5 notification endpoints
- [x] EventBus: `notification.new` + `notification.read` in route table
- [x] Wire: notification service into knowledge_bases, groups, capabilities/resolver
- [x] Frontend: `notifications.js` module
- [x] Frontend: bell icon + unread badge in header
- [x] Frontend: notification dropdown (list, mark read, navigate)
- [x] Frontend: notification panel (full list, registered with PanelRegistry)
- [x] Frontend: WebSocket handler for real-time push
- [x] Frontend: toast for high-priority notification types
- [x] Tests: notification store CRUD (both dialects)
- [x] Tests: notification handler integration tests
- [x] Tests: WebSocket delivery (via existing hub test pattern)
---
## Phase 2 — @mention Parsing + Multi-model Routing
### Concept
Today, each channel has one active model (set via model selector or persona). The `channel_models` table (schema 001) already supports multiple models per channel — it's just never been populated with more than one, and the completion handler ignores it.
Phase 2 activates this table:
1. Users can **add models** to a channel (up to N, configurable, default 5).
2. Messages can contain **@mentions** that route to specific models.
3. The completion handler **fans out** to mentioned model(s), producing one assistant response per model.
4. Without @mention, the **default** channel model responds (backward compatible).
### @mention Syntax
```
@claude-3-opus What do you think about this approach?
@gpt-4 Can you review the code above?
Hey @claude-3-opus and @gpt-4, compare your approaches.
```
Mentions resolve against the `display_name` of `channel_models` entries for the current channel. Resolution is case-insensitive, whitespace-normalized, with longest-match-first to handle model names that are substrings of others.
**Why display_name, not model_id?** Model IDs are composite strings like `anthropic/claude-3-opus-20240229` — terrible UX. `display_name` is user-settable when adding a model to the channel, defaulting to a short friendly name derived from the model catalog (e.g. "Claude 3 Opus", "GPT-4").
### Mention Parser
```go
// server/mentions/parser.go
type Mention struct {
Raw string // "@claude-3-opus" as written
Name string // "claude-3-opus" (normalized, no @)
Start int // byte offset in message content
End int // byte offset end
Resolved *models.ChannelModel // nil if unresolved
}
// Parse extracts @mentions from message content and resolves them
// against the channel's model roster.
func Parse(content string, roster []models.ChannelModel) []Mention
```
**Parser rules:**
- `@` followed by one or more non-whitespace characters.
- Greedy: `@claude-3-opus-20240229` matches the full string, not just `@claude`.
- Resolution: case-insensitive match against `display_name` with hyphens/spaces normalized.
- Unresolved mentions are left as-is in the message (no error, no routing).
- Mentions at any position in the message (start, middle, end).
**Frontend-side autocomplete:** When user types `@` in the chat input, show a dropdown of channel models (fetched from `GET /channels/:id/models`). Selecting inserts the `@display_name` token. This reuses the `[[wikilink` autocomplete pattern from CM6 (v0.17.3) adapted for the plain textarea/CM6 chat input.
### Completion Handler Changes
Current flow (simplified):
```
user message → resolve model → one completion → one assistant message
```
New flow:
```
user message → parse @mentions → resolve target model(s) → fan out completions → N assistant messages
```
```go
// In completion.go, after persisting user message:
// 1. Load channel model roster
roster, _ := h.stores.GetModels(ctx, channel.ID)
// 2. Parse mentions
mentions := mentions.Parse(req.Content, roster)
// 3. Determine target models
var targets []models.ChannelModel
if len(mentions) > 0 {
// Deduplicate resolved mentions
seen := map[string]bool{}
for _, m := range mentions {
if m.Resolved != nil && !seen[m.Resolved.ID] {
targets = append(targets, *m.Resolved)
seen[m.Resolved.ID] = true
}
}
}
if len(targets) == 0 {
// No mentions or none resolved → use default channel model (current behavior)
targets = []models.ChannelModel{defaultModelFromRequest(req, channel, roster)}
}
// 4. Fan out: one completion per target model
for _, target := range targets {
// Each gets its own assistant message with model attribution
go h.completeForModel(ctx, c, req, channel, messages, target)
}
```
**Sequential vs parallel:** Start with **sequential** fan-out (simpler error handling, predictable message ordering). Parallel is a future optimization — the bottleneck is provider latency, not local compute.
**Streaming:** Each model's response streams independently. Frontend receives SSE events tagged with model info:
```json
{"event": "delta", "model": "claude-3-opus", "model_display": "Claude 3 Opus", "content": "..."}
```
Frontend renders each model's response in a separate message bubble with a model attribution label.
### Multi-model Channel UI
**"Add model" button** in the model selector area (chat header):
```
┌──────────────────────────────────────────────────────┐
│ Channel: Project Discussion │
│ Models: [Claude 3 Opus ✕] [GPT-4 ✕] [+ Add model] │
└──────────────────────────────────────────────────────┘
```
- Model pills show `display_name`, click `✕` to remove.
- `[+ Add model]` opens a dropdown of available models (filtered by user's accessible provider configs), with a "Display name" input field.
- Default model indicated with a subtle star/highlight (the one that responds without @mention).
- Click a model pill to set it as default.
**API endpoints:**
```
GET /api/v1/channels/:id/models — list channel models
POST /api/v1/channels/:id/models — add model to channel
DELETE /api/v1/channels/:id/models/:modelId — remove model
PATCH /api/v1/channels/:id/models/:modelId — update display_name, set default, system_prompt
```
These are mostly wrappers around the existing `SetModel`/`GetModels` store methods, with additional CRUD.
### Message Attribution
Assistant messages from multi-model channels get a visual attribution:
```
┌─────────────────────────────────────────┐
│ Claude 3 Opus │
│ I think the recursive approach is... │
├─────────────────────────────────────────┤
│ GPT-4 │
│ I'd suggest an iterative solution... │
└─────────────────────────────────────────┘
```
The `model` field on `messages` already stores the model ID. Frontend renders a label above multi-model assistant messages using the `display_name` from the channel model roster.
### Files Changed (Phase 2)
**New files:**
- `server/mentions/parser.go` — @mention parser
- `server/mentions/parser_test.go` — parser unit tests
- `server/handlers/channel_models.go` — channel model CRUD endpoints
**Modified files:**
- `server/handlers/completion.go` — fan-out logic, mention parsing integration
- `server/handlers/channels.go` — wire channel model routes
- `server/store/interfaces.go` — extend `ChannelStore` with `DeleteModel`, `UpdateModel` (if not already present)
- `server/store/postgres/channel.go` — additional model CRUD
- `server/store/sqlite/channel.go` — same
- `src/js/chat.js` — model pills UI, @mention autocomplete, multi-model message rendering
- `src/js/api.js` — channel model API methods
- `src/css/style.css` — model pill styling, attribution labels
### Checklist (Phase 2)
- [x] Mention parser: `mentions.Parse()` with case-insensitive resolution
- [x] Parser tests: edge cases (no mentions, unresolved, multiple, overlapping names)
- [x] Channel model CRUD handlers (4 endpoints)
- [x] Store: `DeleteModel`, `UpdateModel` for both dialects
- [x] Completion handler: mention extraction → target resolution → fan-out
- [x] SSE streaming: model attribution in delta events
- [x] Frontend: model pills in chat header
- [x] Frontend: add/remove model UI
- [x] Frontend: @mention autocomplete in chat input
- [x] Frontend: model attribution labels on assistant messages
- [x] Frontend: multi-stream rendering (sequential responses, distinct bubbles)
- [x] Integration tests: multi-model completion fan-out
- [x] Integration tests: channel model CRUD
- [x] Backward compat: channels with no `channel_models` rows work exactly as today
---
## Phase 3 — Email Transport + Notification Preferences
### User Notification Preferences
```sql
-- Postgres: 008_v0200_notification_prefs.sql
CREATE TABLE IF NOT EXISTS notification_preferences (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
type VARCHAR(50) NOT NULL, -- notification type or '*' for default
in_app BOOLEAN DEFAULT true,
email BOOLEAN DEFAULT false,
UNIQUE(user_id, type)
);
```
```sql
-- SQLite: 007_v0200_notification_prefs.sql
CREATE TABLE IF NOT EXISTS notification_preferences (
id TEXT PRIMARY KEY,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
type TEXT NOT NULL,
in_app INTEGER DEFAULT 1,
email INTEGER DEFAULT 0,
UNIQUE(user_id, type)
);
```
**Resolution chain:** Specific type preference → user's `*` default → system default (in_app=true, email=false).
### SMTP Configuration
Admin settings (stored in `platform_settings` JSONB, same pattern as existing admin config):
```json
{
"notifications": {
"email_enabled": false,
"smtp_host": "",
"smtp_port": 587,
"smtp_user": "",
"smtp_password": "", // encrypted via vault
"smtp_from": "noreply@chat.example.com",
"smtp_tls": true,
"instance_name": "Chat Switchboard",
"digest_enabled": false,
"digest_interval": "daily" // "hourly" | "daily" | "weekly"
}
}
```
**Implementation:** `server/notifications/email.go` — wraps `net/smtp` with TLS support. Template rendering via Go `html/template` (no external dependency). Two templates per notification type: HTML + plaintext fallback.
### Email Service
```go
// server/notifications/email.go
type EmailTransport struct {
config SMTPConfig
vault *crypto.KeyResolver // decrypt SMTP password
}
func (t *EmailTransport) Send(ctx context.Context, to, subject, htmlBody, textBody string) error
```
### Notification Service Updates
The `Service.Notify()` method gains a preference check:
```go
func (s *Service) Notify(ctx context.Context, n *models.Notification) error {
prefs := s.resolvePrefs(ctx, n.UserID, n.Type)
if prefs.InApp {
s.store.Create(ctx, n)
s.hub.SendToUser(n.UserID, ...)
}
if prefs.Email && s.email != nil {
user, _ := s.stores.GetUser(ctx, n.UserID)
if user.Email != "" {
s.email.Send(ctx, user.Email, n.Title, renderHTML(n), renderText(n))
}
}
return nil
}
```
### Digest Mode
Low-priority notifications (e.g. `grant.changed`) can batch into a periodic email digest:
- Background goroutine checks on interval (hourly/daily).
- Queries `notifications WHERE is_read = false AND created_at > last_digest_at`.
- Groups by user, renders a single digest email per user.
- Marks digested notifications with a `digested_at` timestamp (add column in this migration).
**Deferred if complexity is too high for v0.20.0.** The core value is in-app + individual email. Digest is nice-to-have.
### User Preferences UI
Settings → Notifications:
```
┌────────────────────────────────────────────────┐
│ Notification Preferences │
├────────────────────────────────────────────────┤
│ Type In-App Email │
│ ───────────────────── ─────── ───── │
│ Model fallback [✓] [ ] │
│ KB processing [✓] [✓] │
│ Group membership [✓] [ ] │
│ Default (all others) [✓] [ ] │
└────────────────────────────────────────────────┘
```
### Admin Settings UI
Admin panel → System → Notifications:
- Enable/disable email transport globally.
- SMTP configuration form (host, port, user, password, from address, TLS toggle).
- Test email button (sends to current admin's email).
- Digest toggle + interval selector.
### Files Changed (Phase 3)
**New files:**
- `server/notifications/email.go` — SMTP transport
- `server/notifications/templates.go` — HTML/text email templates
- `server/notifications/digest.go` — digest aggregation (if not deferred)
- `server/store/postgres/notification_prefs.go` — preference store
- `server/store/sqlite/notification_prefs.go` — same
- `server/database/migrations/008_v0200_notification_prefs.sql`
- `server/database/migrations/sqlite/007_v0200_notification_prefs.sql`
**Modified files:**
- `server/notifications/service.go` — preference resolution, email dispatch
- `server/store/interfaces.go` — `NotificationPreferenceStore`
- `server/handlers/notifications.go` — preference CRUD endpoints
- `server/handlers/admin.go` — SMTP config in admin settings
- `src/js/admin-handlers.js` — notification admin UI
- `src/js/app.js` — user notification preferences in settings modal
### Checklist (Phase 3)
- [x] Migration: `notification_preferences` table (both dialects)
- [x] Store: `NotificationPreferenceStore` interface + implementations
- [x] Handlers: preference CRUD endpoints (GET/PUT per type)
- [x] Notification service: preference resolution chain
- [x] Email transport: SMTP with TLS, template rendering
- [x] Email templates: HTML + plaintext for each notification type
- [x] Admin UI: SMTP config + test email button
- [x] User UI: notification preferences in Settings
- [ ] Optional: digest mode (background goroutine + batched email) — deferred
- [x] Tests: preference resolution chain
- [x] Tests: email transport (mock SMTP)
---
## Cross-cutting Concerns
### Retention / Cleanup
Notifications accumulate. Add a cleanup policy:
- Default: retain 90 days, configurable via admin settings (`notifications.retention_days`).
- Cleanup: background goroutine (daily) deletes `WHERE created_at < NOW() - retention`.
- Same pattern as compaction scanner — register in `server/main.go` startup.
### Notification Count Performance
The unread badge polls on app init, then stays current via WebSocket. No periodic polling. Badge syncs across tabs via `notification.read` event (one tab marks read → other tabs update badge).
### SQLite Considerations
- No `LISTEN/NOTIFY` — WebSocket push uses `Hub.SendToUser()` directly (already in-process, no PG dependency).
- `datetime('now')` for `created_at` (standard SQLite pattern).
- `INTEGER` for booleans (standard).
### Mobile
- Notification bell fits in mobile header (replace one of the existing icons or use hamburger menu).
- Notification dropdown becomes full-screen overlay on mobile (same pattern as other dropdowns).
- @mention autocomplete: same touch-friendly dropdown pattern as wikilink autocomplete.
### Security
- Notifications are user-scoped. No cross-user access via API (every query includes `user_id` from auth context).
- SMTP password encrypted at rest via vault (same pattern as API keys in v0.9.4).
- Email transport validates `smtp_host` against SSRF allowlist (same pattern as `url_fetch`).
- @mention parsing sanitized — no injection via display names (names are alphanumeric + hyphens only, validated on `channel_models` write).
---
## Dependency Map
```
Phase 1: Notifications Core
├── notifications table (migration)
├── NotificationStore (postgres + sqlite)
├── Notification Service (create + dispatch)
├── EventBus route (notification.new)
├── API endpoints (5)
├── Frontend: bell + dropdown + panel
└── Wire: KB, groups, resolver → service
Phase 2: @mention + Multi-model ← can start in parallel with Phase 1
├── mentions/parser.go
├── channel_models CRUD endpoints ← table already exists
├── completion handler fan-out
├── Frontend: model pills + autocomplete
└── Frontend: multi-stream rendering
Phase 3: Email + Preferences ← depends on Phase 1
├── notification_preferences table (migration)
├── SMTP transport
├── Email templates
├── Preference resolution in Service
└── Admin + User settings UI
```
Phases 1 and 2 have no code-level dependency on each other — they touch different files and can be developed in parallel or in either order. Phase 3 strictly depends on Phase 1 (extends the notification service).
---
## Version Bump
- `VERSION`: `0.19.2` → `0.20.0` after Phase 2 merge (or after Phase 1 if shipping incrementally as `0.20.0-rc1`).
- Changelog entry after each phase merge.
- No breaking API changes — all additions.
---
## What This Unblocks
- **v0.23.0 Multi-Participant Channels:** Notifications become the backbone for participant join/leave, new message alerts, and assignment queue events.
- **v0.25.0 Workflow Engine:** Stage transition notifications, assignment notifications, completion webhooks all route through the notification service.
- **v0.22.0 Smart Routing:** Multi-model channels demonstrate the fan-out pattern that routing policies will generalize.

65
docs/ROADMAP.md
View File

@@ -76,7 +76,7 @@ v0.19.1 Active Project + System Prompt + Detail Panel ✅
│
v0.19.2 Project Persona Default + Archive + Reorder ✅
│
v0.20.0 Notifications + @mention Routing + Multi-model
v0.20.0 Notifications + @mention Routing + Multi-model ✅
│
v0.21.0 Extension Surfaces + Modes (depends on CM6 from v0.17.2)
│
@@ -601,31 +601,56 @@ Depends on: v0.19.1.
---
## v0.20.0 — Notifications + @mention Routing + Multi-model
## v0.20.0 — Notifications + @mention Routing + Multi-model ✅
Notification infrastructure that makes collaboration real-time, plus
the channel schema already supports multiple models — this adds routing.
multi-model routing for channels. Three-phase delivery: notifications
core (in-app), @mention parsing + fan-out completions, email transport
+ per-user notification preferences.
_(Notifications shifted from v0.19.0; @mention routing shifted from v0.17.0)_
**Notifications**
- [ ] `notifications` table: `id`, `user_id`, `type`, `title`, `body`, `resource_type`, `resource_id`, `is_read`, `created_at`
- [ ] In-app notification bell (header bar, unread count badge)
- [ ] Notification dropdown: grouped by type, mark read, click-to-navigate
- [ ] WebSocket push: real-time delivery via existing EventBus (`notification.new` event)
- [ ] Notification sources: group membership changes, grant updates, KB processing complete, project invites, team invites
- [ ] Email transport (optional): SMTP config in admin settings, per-user opt-in/out
- [ ] Email templates: HTML + plaintext, branded with instance name
- [ ] Digest mode: batch low-priority notifications into periodic email (hourly/daily)
- [ ] Admin settings: enable/disable email, SMTP config, default notification preferences
- [ ] User preferences: per-type toggles (in-app, email, off)
Depends on: v0.19.2 (Projects complete), EventBus + WebSocket hub (v0.9.x),
`channel_models` table (v0.16.0 schema). See
[DESIGN-0.20.0.md](DESIGN-0.20.0.md) for full spec.
**@mention Routing**
- [ ] @mention parsing in messages (users and AI models)
- [ ] Resolve mentions against `channel_models`
- [ ] Multi-model channels: fire completions per mentioned model
- [ ] "Add a model" UI per channel
- [ ] Enables: second opinions, cross-model conversations
**Phase 1 — Notifications Core (in-app)**
- [x] `notifications` table: `id`, `user_id`, `type`, `title`, `body`, `resource_type`, `resource_id`, `is_read`, `created_at` (Postgres + SQLite migrations)
- [x] `NotificationStore` interface + both implementations: Create, ListByUser (paginated), MarkRead, MarkAllRead, Delete, UnreadCount
- [x] `notifications.Service` with `Notify()` / `NotifyMany()` — centralized creation + WebSocket dispatch
- [x] EventBus routes: `notification.new`, `notification.read` (badge sync across tabs)
- [x] API endpoints: list, unread-count, mark-read, mark-all-read, delete (5 endpoints, all user-scoped)
- [x] Initial sources: `role.fallback` (EventBus subscription), `kb.ready`/`kb.error`, `grant.changed`
- [x] Frontend: bell icon + unread badge (capped 9+), notification dropdown (latest 10, click-to-navigate), full panel via PanelRegistry
- [x] WebSocket handler: real-time push + toast for high-priority types
- [x] Background cleanup goroutine (configurable retention, default 90 days)
**Phase 2 — @mention Parsing + Multi-model Routing**
- [x] `mentions.Parse()`: extract @mentions, resolve against channel model roster (case-insensitive, longest-match-first, trailing punctuation tolerant)
- [x] Parser tests: no mentions, unresolved, multiple, overlapping names, punctuation edge cases
- [x] Channel model CRUD handlers (4 endpoints: list, add, remove, update)
- [x] Completion handler: mention extraction → target resolution → sequential fan-out → N assistant messages
- [x] SSE streaming: model attribution in delta events (`model_display` field)
- [x] Frontend: model pills in chat header with add/remove UI
- [x] Frontend: @mention autocomplete via CM6 `mentionCompletion` extension (roster-backed)
- [x] Frontend: model attribution labels on multi-model assistant messages
- [x] Backward compat: channels with no extra `channel_models` rows work exactly as before
**Phase 3 — Email Transport + Notification Preferences**
- [x] `notification_preferences` table (Postgres + SQLite): per-user, per-type in_app/email toggles
- [x] Preference resolution chain: specific type → user wildcard `*` → system default (in_app=true, email=false)
- [x] `EmailTransport`: SMTP with implicit TLS (port 465) and STARTTLS (port 587), multipart MIME (HTML + plaintext)
- [x] Email templates: branded HTML + plaintext, domain-prefixed subjects, Go `html/template`
- [x] Preference CRUD endpoints (3: list, set with partial patch, delete)
- [x] Admin SMTP configuration: enable toggle, host/port/user/password/from/TLS fields, test email button
- [x] User notification preferences UI (Settings → Notifications tab, per-type checkboxes)
- [x] Notification service: preference check before dispatch, async email delivery (goroutine, 30s timeout)
- [x] Tests: preference resolution chain (7 tests), email templates (4 tests)
- [x] Deferred: digest mode (batched email), SMTP password vault encryption
**Hotfix (carried forward from v0.19.2 investigation)**
- [x] `user_model_settings` NULL scan fix: COALESCE on `hidden`/`sort_order` in SELECT + INSERT for both dialects
- [x] Gin release mode: auto-set `gin.ReleaseMode` when `ENVIRONMENT=production`, suppress health check log spam
---

2
k8s/backend.yaml
View File

@@ -62,6 +62,8 @@ spec:
env:
- name: ENVIRONMENT
value: "${ENVIRONMENT}"
- name: GIN_MODE
value: "${GIN_MODE}"
- name: PORT
value: "8080"
- name: BASE_PATH

5
scripts/db-validate.sh
View File

@@ -203,6 +203,11 @@ check_table "project_channels"
check_table "project_knowledge_bases"
check_table "project_notes"
# ── Notifications (v0.20.0) ──────────────
echo ""
echo "Notifications (v0.20.0):"
check_table "notifications"
# ── Users (vault) ────────────────────────
echo ""
echo "Users (vault):"

17
server/database/migrations/007_v0200_notifications.sql Normal file
View File

@@ -0,0 +1,17 @@
-- 007_v0200_notifications.sql
-- Notification infrastructure (v0.20.0 Phase 1)
CREATE TABLE IF NOT EXISTS notifications (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
type VARCHAR(50) NOT NULL,
title VARCHAR(255) NOT NULL,
body TEXT DEFAULT '',
resource_type VARCHAR(50),
resource_id UUID,
is_read BOOLEAN DEFAULT false,
created_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_notifications_user_unread ON notifications(user_id, is_read, created_at DESC);
CREATE INDEX IF NOT EXISTS idx_notifications_user_created ON notifications(user_id, created_at DESC);

18
server/database/migrations/008_v0200_notification_prefs.sql Normal file
View File

@@ -0,0 +1,18 @@
-- 008_v0200_notification_prefs.sql
-- Notification preferences per user per type.
-- Resolution: specific type → user '*' default → system default (in_app=true, email=false).
BEGIN;
CREATE TABLE IF NOT EXISTS notification_preferences (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
type VARCHAR(50) NOT NULL, -- notification type or '*' for default
in_app BOOLEAN NOT NULL DEFAULT true,
email BOOLEAN NOT NULL DEFAULT false,
UNIQUE(user_id, type)
);
CREATE INDEX IF NOT EXISTS idx_notification_prefs_user ON notification_preferences(user_id);
COMMIT;

17
server/database/migrations/sqlite/006_v0200_notifications.sql Normal file
View File

@@ -0,0 +1,17 @@
-- 006_v0200_notifications.sql
-- Notification infrastructure (v0.20.0 Phase 1)
CREATE TABLE IF NOT EXISTS notifications (
id TEXT PRIMARY KEY,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
type TEXT NOT NULL,
title TEXT NOT NULL,
body TEXT DEFAULT '',
resource_type TEXT,
resource_id TEXT,
is_read INTEGER DEFAULT 0,
created_at TEXT DEFAULT (datetime('now'))
);
CREATE INDEX IF NOT EXISTS idx_notifications_user_unread ON notifications(user_id, is_read, created_at DESC);
CREATE INDEX IF NOT EXISTS idx_notifications_user_created ON notifications(user_id, created_at DESC);

13
server/database/migrations/sqlite/007_v0200_notification_prefs.sql Normal file
View File

@@ -0,0 +1,13 @@
-- 007_v0200_notification_prefs.sql
-- Notification preferences per user per type (SQLite dialect).
CREATE TABLE IF NOT EXISTS notification_preferences (
id TEXT PRIMARY KEY,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
type TEXT NOT NULL,
in_app INTEGER NOT NULL DEFAULT 1,
email INTEGER NOT NULL DEFAULT 0,
UNIQUE(user_id, type)
);
CREATE INDEX IF NOT EXISTS idx_notification_prefs_user ON notification_preferences(user_id);

1
server/database/testhelper.go
View File

@@ -256,6 +256,7 @@ func TruncateAll(t *testing.T) {
"resource_grants",
"group_members",
"groups",
"notifications",
"usage_log",
"model_pricing",
"notes",

13
server/events/types.go
View File

@@ -56,6 +56,10 @@ var routeTable = map[string]Direction{
// Role alerts (v0.17.0)
"role.fallback": DirToClient,
// Notifications (v0.20.0)
"notification.new": DirToClient, // targeted via Hub.SendToUser, not room-based
"notification.read": DirToClient, // badge sync across tabs
// Plugin hooks — never cross the wire
"plugin.hook.": DirLocal,
"internal.": DirLocal,
@@ -103,3 +107,12 @@ func ShouldAcceptFromClient(label string) bool {
d := RouteFor(label)
return d == DirFromClient || d == DirBoth
}
// MustJSON marshals v to json.RawMessage, returning {} on error.
func MustJSON(v any) json.RawMessage {
data, err := json.Marshal(v)
if err != nil {
return json.RawMessage(`{}`)
}
return data
}

78
server/handlers/admin_email.go Normal file
View File

@@ -0,0 +1,78 @@
package handlers
import (
"context"
"net/http"
"github.com/gin-gonic/gin"
"git.gobha.me/xcaliber/chat-switchboard/notifications"
"git.gobha.me/xcaliber/chat-switchboard/store"
)
// AdminEmailHandler handles admin SMTP configuration and test endpoints.
type AdminEmailHandler struct {
stores store.Stores
}
// NewAdminEmailHandler creates a new admin email handler.
func NewAdminEmailHandler(s store.Stores) *AdminEmailHandler {
return &AdminEmailHandler{stores: s}
}
// TestEmail sends a test email to the requesting admin's email address.
// POST /api/v1/admin/notifications/test-email
func (h *AdminEmailHandler) TestEmail(c *gin.Context) {
userID := getUserID(c)
if userID == "" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "authentication required"})
return
}
user, err := h.stores.Users.GetByID(c.Request.Context(), userID)
if err != nil || user == nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to load user"})
return
}
if user.Email == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "no email address configured for your account"})
return
}
// Load current SMTP config
cfg, err := notifications.LoadSMTPConfig(h.stores.GlobalConfig, nil)
if err != nil || cfg == nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "SMTP not configured: " + err.Error()})
return
}
transport := notifications.NewEmailTransport(*cfg)
if transport == nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "SMTP configuration is incomplete"})
return
}
// Get instance name
instanceName := "Chat Switchboard"
if branding, err := h.stores.GlobalConfig.Get(context.Background(), "branding"); err == nil {
if name, ok := branding["instance_name"].(string); ok && name != "" {
instanceName = name
}
}
subject := "[" + instanceName + "] Test Email"
htmlBody := `<!DOCTYPE html>
<html><body style="font-family: sans-serif; padding: 20px;">
<h2 style="color: #4a8af4;">` + instanceName + `</h2>
<p>This is a test email from your Chat Switchboard instance.</p>
<p>If you received this, your SMTP configuration is working correctly.</p>
</body></html>`
textBody := instanceName + " — Test Email\n\nThis is a test email. Your SMTP configuration is working correctly."
if err := transport.Send(c.Request.Context(), user.Email, subject, htmlBody, textBody); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "send failed: " + err.Error()})
return
}
c.JSON(http.StatusOK, gin.H{"ok": true, "sent_to": user.Email})
}

237
server/handlers/channel_models.go Normal file
View File

@@ -0,0 +1,237 @@
package handlers
import (
"database/sql"
"net/http"
"github.com/gin-gonic/gin"
"git.gobha.me/xcaliber/chat-switchboard/models"
"git.gobha.me/xcaliber/chat-switchboard/store"
)
// ── Channel Models Handler ──────────────────
// Manages multi-model assignments per channel (v0.20.0 Phase 2).
// Routes:
// GET /channels/:id/models — list
// POST /channels/:id/models — add
// PATCH /channels/:id/models/:modelId — update (display_name, is_default, system_prompt)
// DELETE /channels/:id/models/:modelId — remove
const maxModelsPerChannel = 5
type ChannelModelHandler struct {
stores store.Stores
}
func NewChannelModelHandler(stores store.Stores) *ChannelModelHandler {
return &ChannelModelHandler{stores: stores}
}
// ── List ─────────────────────────────────────
func (h *ChannelModelHandler) List(c *gin.Context) {
channelID := c.Param("id")
userID := getUserID(c)
if !userOwnsChannel(c, channelID, userID) {
return
}
roster, err := h.stores.Channels.GetModels(c.Request.Context(), channelID)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list models"})
return
}
if roster == nil {
roster = []models.ChannelModel{}
}
c.JSON(http.StatusOK, roster)
}
// ── Add ──────────────────────────────────────
type addChannelModelRequest struct {
ModelID string `json:"model_id" binding:"required"`
ProviderConfigID string `json:"provider_config_id"`
DisplayName string `json:"display_name" binding:"required"`
SystemPrompt string `json:"system_prompt"`
IsDefault bool `json:"is_default"`
}
func (h *ChannelModelHandler) Add(c *gin.Context) {
channelID := c.Param("id")
userID := getUserID(c)
if !userOwnsChannel(c, channelID, userID) {
return
}
var req addChannelModelRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
// Check max models limit
existing, err := h.stores.Channels.GetModels(c.Request.Context(), channelID)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to check existing models"})
return
}
if len(existing) >= maxModelsPerChannel {
c.JSON(http.StatusConflict, gin.H{"error": "maximum models per channel reached"})
return
}
// If this is the first model or marked as default, ensure only one default
isDefault := req.IsDefault || len(existing) == 0
cm := &models.ChannelModel{
ChannelID: channelID,
ModelID: req.ModelID,
ProviderConfigID: req.ProviderConfigID,
DisplayName: req.DisplayName,
SystemPrompt: req.SystemPrompt,
IsDefault: isDefault,
}
// SetModel handles INSERT ON CONFLICT (upsert by channel_id + model_id)
if err := h.stores.Channels.SetModel(c.Request.Context(), cm); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to add model"})
return
}
// If this is the new default, clear default on others
if isDefault {
h.clearOtherDefaults(c, channelID, req.ModelID)
}
// Return the updated roster
roster, _ := h.stores.Channels.GetModels(c.Request.Context(), channelID)
c.JSON(http.StatusCreated, gin.H{"models": roster})
}
// ── Update ───────────────────────────────────
type updateChannelModelRequest struct {
DisplayName *string `json:"display_name"`
SystemPrompt *string `json:"system_prompt"`
IsDefault *bool `json:"is_default"`
}
func (h *ChannelModelHandler) Update(c *gin.Context) {
channelID := c.Param("id")
modelRecordID := c.Param("modelId")
userID := getUserID(c)
if !userOwnsChannel(c, channelID, userID) {
return
}
var req updateChannelModelRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
// Verify model belongs to this channel
cm, err := h.stores.Channels.GetModelByID(c.Request.Context(), modelRecordID)
if err == sql.ErrNoRows {
c.JSON(http.StatusNotFound, gin.H{"error": "model not found"})
return
}
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to look up model"})
return
}
if cm.ChannelID != channelID {
c.JSON(http.StatusForbidden, gin.H{"error": "model does not belong to this channel"})
return
}
fields := make(map[string]interface{})
if req.DisplayName != nil {
fields["display_name"] = *req.DisplayName
}
if req.SystemPrompt != nil {
fields["system_prompt"] = *req.SystemPrompt
}
if req.IsDefault != nil {
fields["is_default"] = *req.IsDefault
if *req.IsDefault {
h.clearOtherDefaults(c, channelID, cm.ModelID)
}
}
if len(fields) == 0 {
c.JSON(http.StatusBadRequest, gin.H{"error": "no fields to update"})
return
}
if err := h.stores.Channels.UpdateModel(c.Request.Context(), modelRecordID, fields); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to update model"})
return
}
roster, _ := h.stores.Channels.GetModels(c.Request.Context(), channelID)
c.JSON(http.StatusOK, gin.H{"models": roster})
}
// ── Delete ───────────────────────────────────
func (h *ChannelModelHandler) Delete(c *gin.Context) {
channelID := c.Param("id")
modelRecordID := c.Param("modelId")
userID := getUserID(c)
if !userOwnsChannel(c, channelID, userID) {
return
}
// Verify model belongs to this channel
cm, err := h.stores.Channels.GetModelByID(c.Request.Context(), modelRecordID)
if err == sql.ErrNoRows {
c.JSON(http.StatusNotFound, gin.H{"error": "model not found"})
return
}
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to look up model"})
return
}
if cm.ChannelID != channelID {
c.JSON(http.StatusForbidden, gin.H{"error": "model does not belong to this channel"})
return
}
if err := h.stores.Channels.DeleteModel(c.Request.Context(), modelRecordID); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete model"})
return
}
// If deleted model was default, promote the first remaining model
if cm.IsDefault {
remaining, _ := h.stores.Channels.GetModels(c.Request.Context(), channelID)
if len(remaining) > 0 {
h.stores.Channels.UpdateModel(c.Request.Context(), remaining[0].ID,
map[string]interface{}{"is_default": true})
}
}
roster, _ := h.stores.Channels.GetModels(c.Request.Context(), channelID)
c.JSON(http.StatusOK, gin.H{"models": roster})
}
// ── Helpers ──────────────────────────────────
// clearOtherDefaults sets is_default=false on all models in the channel
// except the one with the given modelID.
func (h *ChannelModelHandler) clearOtherDefaults(c *gin.Context, channelID, keepModelID string) {
roster, _ := h.stores.Channels.GetModels(c.Request.Context(), channelID)
for _, m := range roster {
if m.ModelID != keepModelID && m.IsDefault {
h.stores.Channels.UpdateModel(c.Request.Context(), m.ID,
map[string]interface{}{"is_default": false})
}
}
}

130
server/handlers/completion.go
View File

@@ -18,6 +18,7 @@ import (
"git.gobha.me/xcaliber/chat-switchboard/database"
"git.gobha.me/xcaliber/chat-switchboard/events"
"git.gobha.me/xcaliber/chat-switchboard/knowledge"
"git.gobha.me/xcaliber/chat-switchboard/mentions"
"git.gobha.me/xcaliber/chat-switchboard/models"
"git.gobha.me/xcaliber/chat-switchboard/providers"
"git.gobha.me/xcaliber/chat-switchboard/storage"
@@ -218,6 +219,19 @@ func (h *CompletionHandler) Complete(c *gin.Context) {
}
}
// ── Multi-model @mention routing (v0.20.0) ──────────
// Check if the message @mentions specific channel models.
// If multiple models are targeted, fan out sequentially.
roster, _ := h.stores.Channels.GetModels(c.Request.Context(), channelID)
if len(roster) > 1 {
parsed := mentions.Parse(req.Content, roster)
targets := mentions.ResolvedModels(parsed)
if len(targets) > 1 {
h.multiModelStream(c, targets, messages, channelID, userID, personaID, presetSystemPrompt, req)
return
}
}
// Build provider request
provReq := providers.CompletionRequest{
Model: model,
@@ -257,6 +271,122 @@ func (h *CompletionHandler) Complete(c *gin.Context) {
}
}
// ── Multi-Model Sequential Stream (v0.20.0) ──
// multiModelStream handles the case where a message @mentions multiple
// channel models. It streams each model's response sequentially within
// a single SSE response, sending model_start/model_end delimiters.
func (h *CompletionHandler) multiModelStream(
c *gin.Context,
targets []models.ChannelModel,
messages []providers.Message,
channelID, userID, personaID, presetSystemPrompt string,
req completionRequest,
) {
// Set SSE headers once for the entire multi-model stream
c.Header("Content-Type", "text/event-stream")
c.Header("Cache-Control", "no-cache")
c.Header("Connection", "keep-alive")
c.Header("X-Accel-Buffering", "no")
c.Status(http.StatusOK)
flusher, _ := c.Writer.(http.Flusher)
flush := func() {
if flusher != nil {
flusher.Flush()
}
}
sendSSE := func(data string) {
fmt.Fprintf(c.Writer, "data: %s\n\n", data)
flush()
}
sendEvent := func(event, data string) {
fmt.Fprintf(c.Writer, "event: %s\ndata: %s\n\n", event, data)
flush()
}
for _, target := range targets {
// Notify client which model is about to respond
startJSON, _ := json.Marshal(map[string]string{
"model_id": target.ModelID,
"display_name": target.DisplayName,
})
sendEvent("model_start", string(startJSON))
// Resolve config for this specific model
targetReq := req
targetReq.Model = target.ModelID
if target.ProviderConfigID != "" {
targetReq.APIConfigID = target.ProviderConfigID
}
providerCfg, providerID, model, configID, providerScope, err := h.resolveConfig(userID, channelID, targetReq)
if err != nil {
sendSSE(fmt.Sprintf(`{"error":"failed to resolve config for %s: %s"}`, target.DisplayName, escapeJSON(err.Error())))
sendEvent("model_end", string(startJSON))
continue
}
provider, err := providers.Get(providerID)
if err != nil {
sendSSE(fmt.Sprintf(`{"error":"provider unavailable for %s"}`, target.DisplayName))
sendEvent("model_end", string(startJSON))
continue
}
// Build per-model messages (inject model-specific system prompt if set)
modelMessages := make([]providers.Message, len(messages))
copy(modelMessages, messages)
if target.SystemPrompt != "" {
// Prepend model-specific system prompt
modelMessages = append([]providers.Message{{
Role: "system",
Content: target.SystemPrompt,
}}, modelMessages...)
}
caps := h.getModelCapabilities(c, model, configID)
provReq := providers.CompletionRequest{
Model: model,
Messages: modelMessages,
}
if targetReq.MaxTokens > 0 {
provReq.MaxTokens = targetReq.MaxTokens
} else {
provReq.MaxTokens = capspkg.ResolveMaxOutput(model, caps)
}
if targetReq.Temperature != nil {
provReq.Temperature = targetReq.Temperature
}
if targetReq.TopP != nil {
provReq.TopP = targetReq.TopP
}
hasBrowserTools := h.hub != nil && h.hub.IsConnected(userID)
if caps.ToolCalling && (tools.HasTools() || hasBrowserTools) {
provReq.Tools = h.buildToolDefs(c.Request.Context(), userID, hasBrowserTools, req.DisabledTools)
}
// Stream this model's response using the shared streaming core
result := streamModelResponse(c, provider, providerCfg, &provReq, model, target.DisplayName, userID, channelID, personaID, h.hub)
// Persist assistant message with model attribution
if result.Content != "" {
if _, err := h.persistMessage(channelID, userID, "assistant", result.Content, model, result.InputTokens, result.OutputTokens, nil, toolActivityJSON(result.ToolActivity)); err != nil {
log.Printf("Failed to persist multi-model assistant message: %v", err)
}
}
// Log usage
h.logUsage(c, channelID, userID, configID, providerScope, model,
result.InputTokens, result.OutputTokens,
result.CacheCreationTokens, result.CacheReadTokens)
sendEvent("model_end", string(startJSON))
}
sendSSE("[DONE]")
}
// buildToolDefs converts registered tools to provider-format tool definitions.
// If includeBrowser is true, also fetches tool schemas from enabled browser extensions.
// Tools whose names appear in disabledTools are excluded.

21
server/handlers/groups.go
View File

@@ -8,6 +8,7 @@ import (
"git.gobha.me/xcaliber/chat-switchboard/database"
"git.gobha.me/xcaliber/chat-switchboard/models"
"git.gobha.me/xcaliber/chat-switchboard/notifications"
"git.gobha.me/xcaliber/chat-switchboard/store"
)
@@ -202,16 +203,26 @@ func (h *GroupHandler) AddMember(c *gin.Context) {
}
// Verify group exists
if _, err := h.stores.Groups.GetByID(c.Request.Context(), groupID); err == sql.ErrNoRows {
group, err := h.stores.Groups.GetByID(c.Request.Context(), groupID)
if err == sql.ErrNoRows {
c.JSON(http.StatusNotFound, gin.H{"error": "group not found"})
return
}
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to look up group"})
return
}
if err := h.stores.Groups.AddMember(c.Request.Context(), groupID, req.UserID, actorID); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to add member"})
return
}
// Notify the added user (v0.20.0)
if svc := notifications.Default(); svc != nil {
notifications.NotifyGroupMemberAdded(svc, req.UserID, groupID, group.Name)
}
c.JSON(http.StatusOK, gin.H{"ok": true})
AuditLog(c, "group.member.add", "group", groupID, map[string]interface{}{
"user_id": req.UserID,
@@ -224,6 +235,9 @@ func (h *GroupHandler) RemoveMember(c *gin.Context) {
groupID := c.Param("id")
userID := c.Param("userId")
// Fetch group name for notification before removal
group, _ := h.stores.Groups.GetByID(c.Request.Context(), groupID)
err := h.stores.Groups.RemoveMember(c.Request.Context(), groupID, userID)
if err == sql.ErrNoRows {
c.JSON(http.StatusNotFound, gin.H{"error": "member not found"})
@@ -234,6 +248,11 @@ func (h *GroupHandler) RemoveMember(c *gin.Context) {
return
}
// Notify the removed user (v0.20.0)
if svc := notifications.Default(); svc != nil && group != nil {
notifications.NotifyGroupMemberRemoved(svc, userID, groupID, group.Name)
}
c.JSON(http.StatusOK, gin.H{"ok": true})
AuditLog(c, "group.member.remove", "group", groupID, map[string]interface{}{
"user_id": userID,

281
server/handlers/notifications.go Normal file
View File

@@ -0,0 +1,281 @@
package handlers
import (
"database/sql"
"encoding/json"
"net/http"
"strconv"
"time"
"github.com/gin-gonic/gin"
"git.gobha.me/xcaliber/chat-switchboard/events"
"git.gobha.me/xcaliber/chat-switchboard/models"
"git.gobha.me/xcaliber/chat-switchboard/store"
)
// ── Handler ─────────────────────────────────
// NotificationHandler handles notification CRUD endpoints.
type NotificationHandler struct {
stores store.Stores
hub *events.Hub
}
// NewNotificationHandler creates a new notification handler.
func NewNotificationHandler(s store.Stores, hub *events.Hub) *NotificationHandler {
return &NotificationHandler{stores: s, hub: hub}
}
// ── GET /api/v1/notifications ───────────────
// Returns paginated notifications for the authenticated user.
// Query params: ?limit=20&offset=0&unread_only=false
func (h *NotificationHandler) List(c *gin.Context) {
userID := getUserID(c)
if userID == "" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "authentication required"})
return
}
limit, _ := strconv.Atoi(c.DefaultQuery("limit", "20"))
offset, _ := strconv.Atoi(c.DefaultQuery("offset", "0"))
unreadOnly := c.Query("unread_only") == "true"
if limit <= 0 || limit > 100 {
limit = 20
}
if offset < 0 {
offset = 0
}
items, total, err := h.stores.Notifications.ListByUser(
c.Request.Context(), userID, limit, offset, unreadOnly)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "query failed"})
return
}
c.JSON(http.StatusOK, gin.H{
"data": items,
"total": total,
"limit": limit,
"offset": offset,
})
}
// ── GET /api/v1/notifications/unread-count ──
func (h *NotificationHandler) UnreadCount(c *gin.Context) {
userID := getUserID(c)
if userID == "" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "authentication required"})
return
}
count, err := h.stores.Notifications.UnreadCount(c.Request.Context(), userID)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "query failed"})
return
}
c.JSON(http.StatusOK, gin.H{"count": count})
}
// ── PATCH /api/v1/notifications/:id/read ────
func (h *NotificationHandler) MarkRead(c *gin.Context) {
userID := getUserID(c)
if userID == "" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "authentication required"})
return
}
id := c.Param("id")
if id == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "notification id required"})
return
}
if err := h.stores.Notifications.MarkRead(c.Request.Context(), id, userID); err != nil {
if err == sql.ErrNoRows {
c.JSON(http.StatusNotFound, gin.H{"error": "notification not found"})
return
}
c.JSON(http.StatusInternalServerError, gin.H{"error": "update failed"})
return
}
// Sync badge across tabs
if h.hub != nil {
payload, _ := json.Marshal(map[string]string{"id": id})
h.hub.SendToUser(userID, events.Event{
Label: "notification.read",
Payload: payload,
Ts: time.Now().UnixMilli(),
})
}
c.JSON(http.StatusOK, gin.H{"ok": true})
}
// ── POST /api/v1/notifications/mark-all-read ─
func (h *NotificationHandler) MarkAllRead(c *gin.Context) {
userID := getUserID(c)
if userID == "" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "authentication required"})
return
}
if err := h.stores.Notifications.MarkAllRead(c.Request.Context(), userID); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "update failed"})
return
}
// Sync badge across tabs
if h.hub != nil {
payload, _ := json.Marshal(map[string]string{"action": "mark_all_read"})
h.hub.SendToUser(userID, events.Event{
Label: "notification.read",
Payload: payload,
Ts: time.Now().UnixMilli(),
})
}
c.JSON(http.StatusOK, gin.H{"ok": true})
}
// ── DELETE /api/v1/notifications/:id ────────
func (h *NotificationHandler) Delete(c *gin.Context) {
userID := getUserID(c)
if userID == "" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "authentication required"})
return
}
id := c.Param("id")
if id == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "notification id required"})
return
}
if err := h.stores.Notifications.Delete(c.Request.Context(), id, userID); err != nil {
if err == sql.ErrNoRows {
c.JSON(http.StatusNotFound, gin.H{"error": "notification not found"})
return
}
c.JSON(http.StatusInternalServerError, gin.H{"error": "delete failed"})
return
}
c.JSON(http.StatusOK, gin.H{"ok": true})
}
// ── Notification Preferences (v0.20.0 Phase 3) ──
// GET /api/v1/notifications/preferences
func (h *NotificationHandler) ListPreferences(c *gin.Context) {
userID := getUserID(c)
if userID == "" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "authentication required"})
return
}
if h.stores.NotifPrefs == nil {
c.JSON(http.StatusOK, []models.NotificationPreference{})
return
}
prefs, err := h.stores.NotifPrefs.ListForUser(c.Request.Context(), userID)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "query failed"})
return
}
if prefs == nil {
prefs = []models.NotificationPreference{}
}
c.JSON(http.StatusOK, prefs)
}
// PUT /api/v1/notifications/preferences/:type
func (h *NotificationHandler) SetPreference(c *gin.Context) {
userID := getUserID(c)
if userID == "" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "authentication required"})
return
}
notifType := c.Param("type")
if notifType == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "type is required"})
return
}
var req struct {
InApp *bool `json:"in_app"`
Email *bool `json:"email"`
}
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
if h.stores.NotifPrefs == nil {
c.JSON(http.StatusServiceUnavailable, gin.H{"error": "preferences not available"})
return
}
// Load existing or create new
existing, _ := h.stores.NotifPrefs.Get(c.Request.Context(), userID, notifType)
pref := &models.NotificationPreference{
UserID: userID,
Type: notifType,
InApp: true, // default
Email: false, // default
}
if existing != nil {
pref = existing
}
if req.InApp != nil {
pref.InApp = *req.InApp
}
if req.Email != nil {
pref.Email = *req.Email
}
if err := h.stores.NotifPrefs.Upsert(c.Request.Context(), pref); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "save failed"})
return
}
c.JSON(http.StatusOK, pref)
}
// DELETE /api/v1/notifications/preferences/:type
func (h *NotificationHandler) DeletePreference(c *gin.Context) {
userID := getUserID(c)
if userID == "" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "authentication required"})
return
}
notifType := c.Param("type")
if notifType == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "type is required"})
return
}
if h.stores.NotifPrefs == nil {
c.JSON(http.StatusServiceUnavailable, gin.H{"error": "preferences not available"})
return
}
if err := h.stores.NotifPrefs.Delete(c.Request.Context(), userID, notifType); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "delete failed"})
return
}
c.JSON(http.StatusOK, gin.H{"ok": true})
}

175
server/handlers/stream_loop.go
View File

@@ -240,6 +240,181 @@ func streamWithToolLoop(
const browserToolTimeout = 30 * time.Second
// streamModelResponse is a variant of streamWithToolLoop used by multi-model
// fan-out (v0.20.0). It streams a single model's response within an already-
// established SSE connection — it does NOT set SSE headers or send [DONE].
//
// SSE deltas include a "model_display" field so the frontend can attribute
// each response to the correct model.
func streamModelResponse(
c *gin.Context,
provider providers.Provider,
cfg providers.ProviderConfig,
req *providers.CompletionRequest,
model, displayName, userID, channelID, personaID string,
hub *events.Hub,
) streamResult {
flusher, _ := c.Writer.(http.Flusher)
flush := func() {
if flusher != nil {
flusher.Flush()
}
}
sendSSE := func(data string) {
fmt.Fprintf(c.Writer, "data: %s\n\n", data)
flush()
}
sendEvent := func(event, data string) {
fmt.Fprintf(c.Writer, "event: %s\ndata: %s\n\n", event, data)
flush()
}
var result streamResult
for iteration := 0; iteration < maxToolIterations; iteration++ {
ch, err := provider.StreamCompletion(c.Request.Context(), cfg, *req)
if err != nil {
sendSSE(fmt.Sprintf(`{"error":"%s"}`, escapeJSON(err.Error())))
return result
}
var iterContent string
var iterReasoning string
var toolCalls []providers.ToolCall
for event := range ch {
if event.Error != nil {
sendSSE(fmt.Sprintf(`{"error":"%s"}`, escapeJSON(event.Error.Error())))
return result
}
if event.Reasoning != "" {
iterReasoning += event.Reasoning
sendSSE(fmt.Sprintf(
`{"choices":[{"delta":{"reasoning_content":%q},"finish_reason":null}],"model":%q,"model_display":%q}`,
event.Reasoning, model, displayName))
}
if event.Delta != "" {
iterContent += event.Delta
sendSSE(fmt.Sprintf(
`{"choices":[{"delta":{"content":%q},"finish_reason":null}],"model":%q,"model_display":%q}`,
event.Delta, model, displayName))
}
if event.Done {
if event.FinishReason == "tool_calls" && len(event.ToolCalls) > 0 {
toolCalls = event.ToolCalls
result.InputTokens += event.InputTokens
result.OutputTokens += event.OutputTokens
result.CacheCreationTokens += event.CacheCreationTokens
result.CacheReadTokens += event.CacheReadTokens
} else {
finishReason := event.FinishReason
if finishReason == "" {
finishReason = "stop"
}
if iterReasoning != "" {
result.Content += "<think>" + iterReasoning + "</think>"
}
result.Content += iterContent
result.InputTokens += event.InputTokens
result.OutputTokens += event.OutputTokens
result.CacheCreationTokens += event.CacheCreationTokens
result.CacheReadTokens += event.CacheReadTokens
sendSSE(fmt.Sprintf(
`{"choices":[{"delta":{},"finish_reason":%q}],"model":%q,"model_display":%q}`,
finishReason, model, displayName))
// Do NOT send [DONE] — caller manages that for multi-model
return result
}
break
}
}
// Tool execution (same logic as streamWithToolLoop)
if len(toolCalls) == 0 {
if iterReasoning != "" {
result.Content += "<think>" + iterReasoning + "</think>"
}
result.Content += iterContent
return result
}
toolCallsJSON, _ := json.Marshal(toolCalls)
sendEvent("tool_use", string(toolCallsJSON))
assistantMsg := providers.Message{
Role: "assistant",
Content: iterContent,
}
for _, tc := range toolCalls {
assistantMsg.ToolCalls = append(assistantMsg.ToolCalls, tc)
}
req.Messages = append(req.Messages, assistantMsg)
execCtx := tools.ExecutionContext{
UserID: userID,
ChannelID: channelID,
PersonaID: personaID,
}
for _, tc := range toolCalls {
call := tools.ToolCall{
ID: tc.ID,
Name: tc.Function.Name,
Arguments: tc.Function.Arguments,
}
var toolResult tools.ToolResult
if tools.Get(call.Name) != nil {
toolResult = tools.ExecuteCall(c.Request.Context(), execCtx, call)
} else if hub != nil && hub.IsConnected(userID) {
toolResult = executeBrowserTool(hub, userID, call)
} else {
toolResult = tools.ToolResult{
ToolCallID: call.ID,
Name: call.Name,
Content: `{"error":"unknown tool or browser not connected"}`,
IsError: true,
}
}
resultJSON, _ := json.Marshal(map[string]interface{}{
"tool_call_id": toolResult.ToolCallID,
"name": toolResult.Name,
"content": toolResult.Content,
"is_error": toolResult.IsError,
})
sendEvent("tool_result", string(resultJSON))
result.ToolActivity = append(result.ToolActivity, map[string]interface{}{
"id": tc.ID,
"name": tc.Function.Name,
"arguments": tc.Function.Arguments,
"result": toolResult.Content,
"is_error": toolResult.IsError,
})
req.Messages = append(req.Messages, providers.Message{
Role: "tool",
Content: toolResult.Content,
ToolCallID: toolResult.ToolCallID,
Name: toolResult.Name,
})
}
result.Content += iterContent
}
// Hit max iterations
log.Printf("⚠️ Multi-model tool loop hit max iterations (%d) for model %s", maxToolIterations, displayName)
sendSSE(fmt.Sprintf(
`{"choices":[{"delta":{"content":"%s"},"finish_reason":"stop"}],"model":%q,"model_display":%q}`,
escapeJSON("[Tool execution limit reached]"), model, displayName))
return result
}
// executeBrowserTool sends a tool call to the user's browser via WebSocket
// and blocks until a result is returned or the timeout elapses.
func executeBrowserTool(hub *events.Hub, userID string, call tools.ToolCall) tools.ToolResult {

10
server/knowledge/ingest.go
View File

@@ -10,6 +10,7 @@ import (
"time"
"git.gobha.me/xcaliber/chat-switchboard/models"
"git.gobha.me/xcaliber/chat-switchboard/notifications"
"git.gobha.me/xcaliber/chat-switchboard/storage"
"git.gobha.me/xcaliber/chat-switchboard/store"
)
@@ -85,6 +86,10 @@ func (ing *Ingester) IngestDocument(kb *models.KnowledgeBase, doc *models.KBDocu
log.Printf("❌ ingest doc %s (%s): %v", doc.ID, doc.Filename, err)
ing.stores.KnowledgeBases.UpdateDocumentStatus(ctx, doc.ID, "error", &errMsg)
ing.stores.KnowledgeBases.Update(ctx, kb.ID, map[string]interface{}{"status": "active"})
// Notify document owner of ingestion failure (v0.20.0)
if svc := notifications.Default(); svc != nil {
notifications.NotifyKBError(svc, userID, kb.ID, kb.Name, errMsg)
}
}
}()
}
@@ -205,6 +210,11 @@ func (ing *Ingester) ingest(ctx context.Context, kb *models.KnowledgeBase, doc *
log.Printf(" ✓ ingest complete: %s (%d chunks, %s)",
doc.Filename, len(chunks), time.Since(start).Round(time.Millisecond))
// Notify document owner of successful ingestion (v0.20.0)
if svc := notifications.Default(); svc != nil {
notifications.NotifyKBReady(svc, userID, kb.ID, kb.Name, len(chunks))
}
return nil
}

54
server/main.go
View File

@@ -21,6 +21,7 @@ import (
"git.gobha.me/xcaliber/chat-switchboard/knowledge"
"git.gobha.me/xcaliber/chat-switchboard/memory"
"git.gobha.me/xcaliber/chat-switchboard/middleware"
"git.gobha.me/xcaliber/chat-switchboard/notifications"
"git.gobha.me/xcaliber/chat-switchboard/providers"
"git.gobha.me/xcaliber/chat-switchboard/roles"
"git.gobha.me/xcaliber/chat-switchboard/storage"
@@ -185,6 +186,35 @@ func main() {
// ── WebSocket Hub ─────────────────────────
hub := events.NewHub(bus)
// ── Notification Service (v0.20.0) ───────
var notifSvc *notifications.Service
if stores.Notifications != nil {
notifSvc = notifications.NewService(stores.Notifications, hub).
WithPrefs(stores.NotifPrefs).
WithUsers(stores.Users)
// Load SMTP config from platform settings for email transport (Phase 3)
if stores.GlobalConfig != nil {
if smtpCfg, err := notifications.LoadSMTPConfig(stores.GlobalConfig, keyResolver); err == nil && smtpCfg != nil {
transport := notifications.NewEmailTransport(*smtpCfg)
instanceName := "Chat Switchboard"
if brandCfg, err := stores.GlobalConfig.Get(context.Background(), "branding"); err == nil {
if name, ok := brandCfg["instance_name"].(string); ok && name != "" {
instanceName = name
}
}
notifSvc.WithEmail(transport, instanceName)
log.Println("[notifications] email transport enabled")
}
}
notifSvc.StartCleanup()
notifications.SetDefault(notifSvc)
// Subscribe to role.fallback events → generate notifications for admins
bus.Subscribe("role.fallback", notifications.RoleFallbackHandler(notifSvc, stores))
defer notifSvc.StopCleanup()
}
// Health check (k8s probes hit this directly)
base.GET("/health", func(c *gin.Context) {
c.JSON(200, gin.H{
@@ -246,6 +276,13 @@ func main() {
protected.PUT("/channels/:id", channels.UpdateChannel)
protected.DELETE("/channels/:id", channels.DeleteChannel)
// Channel models (v0.20.0 — multi-model @mention routing)
chModelH := handlers.NewChannelModelHandler(stores)
protected.GET("/channels/:id/models", chModelH.List)
protected.POST("/channels/:id/models", chModelH.Add)
protected.PATCH("/channels/:id/models/:modelId", chModelH.Update)
protected.DELETE("/channels/:id/models/:modelId", chModelH.Delete)
// Messages
msgs := handlers.NewMessageHandler(keyResolver, stores, hub, objStore)
protected.GET("/channels/:id/messages", msgs.ListMessages)
@@ -350,6 +387,19 @@ func main() {
protected.DELETE("/projects/:id/notes/:noteId", projectH.RemoveNote)
protected.GET("/projects/:id/notes", projectH.ListNotes)
// Notifications (v0.20.0)
notifH := handlers.NewNotificationHandler(stores, hub)
protected.GET("/notifications", notifH.List)
protected.GET("/notifications/unread-count", notifH.UnreadCount)
protected.PATCH("/notifications/:id/read", notifH.MarkRead)
protected.POST("/notifications/mark-all-read", notifH.MarkAllRead)
protected.DELETE("/notifications/:id", notifH.Delete)
// Notification preferences (v0.20.0 Phase 3)
protected.GET("/notifications/preferences", notifH.ListPreferences)
protected.PUT("/notifications/preferences/:type", notifH.SetPreference)
protected.DELETE("/notifications/preferences/:type", notifH.DeletePreference)
// Attachments (file upload/download)
attachH := handlers.NewAttachmentHandler(stores, objStore, extQueue)
protected.POST("/channels/:id/attachments", attachH.Upload)
@@ -563,6 +613,10 @@ func main() {
// Vault
admin.GET("/vault/status", adm.VaultStatus)
// Email / SMTP test (v0.20.0 Phase 3)
emailAdm := handlers.NewAdminEmailHandler(stores)
admin.POST("/notifications/test-email", emailAdm.TestEmail)
// Storage management (orphan cleanup)
attachAdm := handlers.NewAttachmentHandler(stores, objStore, extQueue)
admin.GET("/storage/orphans", attachAdm.OrphanCount)

155
server/mentions/parser.go Normal file
View File

@@ -0,0 +1,155 @@
package mentions
import (
"sort"
"strings"
"unicode"
"git.gobha.me/xcaliber/chat-switchboard/models"
)
// Mention represents a parsed @mention token in message content.
type Mention struct {
Raw string // "@claude-3-opus" as written (includes @)
Name string // "claude-3-opus" (normalized, no @)
Start int // byte offset in message content
End int // byte offset end (exclusive)
Resolved *models.ChannelModel // nil if unresolved
}
// Parse extracts @mentions from message content and resolves them
// against the channel's model roster.
//
// Rules:
// - @ followed by one or more non-whitespace characters
// - Greedy: @claude-3-opus-20240229 matches the full token
// - Resolution: case-insensitive match against display_name with
// hyphens/spaces normalized (e.g. "claude 3 opus" matches "Claude-3-Opus")
// - Longest-match-first when display names overlap
// - Unresolved mentions are included with Resolved = nil
// - @ must be at start of content or preceded by whitespace
func Parse(content string, roster []models.ChannelModel) []Mention {
if len(roster) == 0 || !strings.Contains(content, "@") {
return nil
}
// Build lookup: normalized display_name → *ChannelModel
// Sort roster by display_name length descending for longest-match-first
type entry struct {
normalized string
model models.ChannelModel
}
entries := make([]entry, 0, len(roster))
for _, cm := range roster {
if cm.DisplayName == "" {
continue
}
entries = append(entries, entry{
normalized: normalize(cm.DisplayName),
model: cm,
})
}
sort.Slice(entries, func(i, j int) bool {
return len(entries[i].normalized) > len(entries[j].normalized)
})
// Extract @tokens
var mentions []Mention
i := 0
for i < len(content) {
if content[i] != '@' {
i++
continue
}
// @ must be at start or preceded by whitespace
if i > 0 && !unicode.IsSpace(rune(content[i-1])) {
i++
continue
}
// Extract the token after @
start := i
i++ // skip @
tokenStart := i
for i < len(content) && !unicode.IsSpace(rune(content[i])) {
i++
}
if i == tokenStart {
continue // bare @ with no token
}
// Strip trailing punctuation (commas, periods, etc.)
tokenEnd := i
for tokenEnd > tokenStart && isMentionTrailingPunct(content[tokenEnd-1]) {
tokenEnd--
}
if tokenEnd == tokenStart {
continue // all punctuation
}
raw := content[start:tokenEnd]
name := content[tokenStart:tokenEnd]
normalizedName := normalize(name)
// Try to resolve against roster (longest match first)
var resolved *models.ChannelModel
for idx := range entries {
if normalizedName == entries[idx].normalized {
cm := entries[idx].model
resolved = &cm
break
}
}
mentions = append(mentions, Mention{
Raw: raw,
Name: name,
Start: start,
End: tokenEnd,
Resolved: resolved,
})
}
return mentions
}
// ResolvedModels returns deduplicated resolved models from parsed mentions.
// Returns nil if no mentions resolved.
func ResolvedModels(mentions []Mention) []models.ChannelModel {
if len(mentions) == 0 {
return nil
}
seen := make(map[string]bool)
var result []models.ChannelModel
for _, m := range mentions {
if m.Resolved != nil && !seen[m.Resolved.ID] {
seen[m.Resolved.ID] = true
result = append(result, *m.Resolved)
}
}
return result
}
// isMentionTrailingPunct returns true for punctuation that commonly
// follows an @mention but isn't part of the name.
func isMentionTrailingPunct(b byte) bool {
switch b {
case ',', '.', '!', '?', ':', ';', ')', ']', '}':
return true
}
return false
}
// normalize converts a display name to a canonical form for matching:
// lowercase, hyphens → spaces collapsed, trimmed.
func normalize(s string) string {
s = strings.ToLower(s)
s = strings.ReplaceAll(s, "-", " ")
s = strings.ReplaceAll(s, "_", " ")
// Collapse multiple spaces
fields := strings.Fields(s)
return strings.Join(fields, " ")
}

213
server/mentions/parser_test.go Normal file
View File

@@ -0,0 +1,213 @@
package mentions
import (
"testing"
"git.gobha.me/xcaliber/chat-switchboard/models"
)
func roster() []models.ChannelModel {
return []models.ChannelModel{
{ID: "1", ChannelID: "ch1", ModelID: "anthropic/claude-3-opus", DisplayName: "Claude-3-Opus", IsDefault: true},
{ID: "2", ChannelID: "ch1", ModelID: "openai/gpt-4", DisplayName: "GPT-4"},
{ID: "3", ChannelID: "ch1", ModelID: "anthropic/claude-3-haiku", DisplayName: "Claude-3-Haiku"},
}
}
func TestParse_NoMentions(t *testing.T) {
m := Parse("Hello, how are you?", roster())
if len(m) != 0 {
t.Fatalf("expected 0 mentions, got %d", len(m))
}
}
func TestParse_EmptyRoster(t *testing.T) {
m := Parse("@gpt-4 hello", nil)
if len(m) != 0 {
t.Fatalf("expected 0 mentions with empty roster, got %d", len(m))
}
}
func TestParse_SingleMention(t *testing.T) {
m := Parse("@GPT-4 what do you think?", roster())
if len(m) != 1 {
t.Fatalf("expected 1 mention, got %d", len(m))
}
if m[0].Name != "GPT-4" {
t.Errorf("expected Name='GPT-4', got %q", m[0].Name)
}
if m[0].Resolved == nil {
t.Fatal("expected resolved, got nil")
}
if m[0].Resolved.ID != "2" {
t.Errorf("expected resolved to GPT-4 (ID=2), got ID=%s", m[0].Resolved.ID)
}
}
func TestParse_CaseInsensitive(t *testing.T) {
m := Parse("@claude-3-opus please help", roster())
if len(m) != 1 || m[0].Resolved == nil {
t.Fatal("expected 1 resolved mention")
}
if m[0].Resolved.ID != "1" {
t.Errorf("expected Claude-3-Opus (ID=1), got ID=%s", m[0].Resolved.ID)
}
}
func TestParse_MultipleMentions(t *testing.T) {
m := Parse("Hey @Claude-3-Opus and @GPT-4, compare your approaches.", roster())
if len(m) != 2 {
t.Fatalf("expected 2 mentions, got %d", len(m))
}
if m[0].Resolved == nil || m[0].Resolved.ID != "1" {
t.Errorf("first mention: expected Claude-3-Opus")
}
if m[1].Resolved == nil || m[1].Resolved.ID != "2" {
t.Errorf("second mention: expected GPT-4")
}
}
func TestParse_UnresolvedMention(t *testing.T) {
m := Parse("@nonexistent-model hello", roster())
if len(m) != 1 {
t.Fatalf("expected 1 mention, got %d", len(m))
}
if m[0].Resolved != nil {
t.Errorf("expected unresolved mention, got resolved to %s", m[0].Resolved.DisplayName)
}
}
func TestParse_MixedResolvedUnresolved(t *testing.T) {
m := Parse("@GPT-4 and @fake-model what?", roster())
if len(m) != 2 {
t.Fatalf("expected 2 mentions, got %d", len(m))
}
if m[0].Resolved == nil {
t.Error("first mention should resolve")
}
if m[1].Resolved != nil {
t.Error("second mention should not resolve")
}
}
func TestParse_MentionAtStart(t *testing.T) {
m := Parse("@GPT-4", roster())
if len(m) != 1 || m[0].Resolved == nil {
t.Fatal("expected 1 resolved mention at start")
}
}
func TestParse_MentionInMiddle(t *testing.T) {
m := Parse("Ask @GPT-4 about this", roster())
if len(m) != 1 || m[0].Resolved == nil {
t.Fatal("expected 1 resolved mention in middle")
}
}
func TestParse_NoSpaceBefore(t *testing.T) {
// email@GPT-4 should NOT be parsed as a mention
m := Parse("email@GPT-4 test", roster())
if len(m) != 0 {
t.Fatalf("expected 0 mentions (no space before @), got %d", len(m))
}
}
func TestParse_BareAt(t *testing.T) {
m := Parse("@ nothing", roster())
if len(m) != 0 {
t.Fatalf("expected 0 mentions for bare @, got %d", len(m))
}
}
func TestParse_HyphenSpaceNormalization(t *testing.T) {
// Display name "Claude-3-Opus" should match "@claude_3_opus" (underscore normalization)
m := Parse("@claude_3_opus help", roster())
if len(m) != 1 || m[0].Resolved == nil {
t.Fatal("expected underscore-normalized match")
}
if m[0].Resolved.ID != "1" {
t.Errorf("expected Claude-3-Opus, got %s", m[0].Resolved.DisplayName)
}
}
func TestParse_ByteOffsets(t *testing.T) {
content := "Hey @GPT-4 ok"
m := Parse(content, roster())
if len(m) != 1 {
t.Fatal("expected 1 mention")
}
if m[0].Start != 4 || m[0].End != 10 {
t.Errorf("expected offsets [4,10), got [%d,%d)", m[0].Start, m[0].End)
}
if content[m[0].Start:m[0].End] != "@GPT-4" {
t.Errorf("offsets don't match: %q", content[m[0].Start:m[0].End])
}
}
func TestParse_TrailingPunctuation(t *testing.T) {
// Comma, period, exclamation should be stripped
tests := []struct {
input string
want int // expected resolved count
}{
{"@GPT-4, what?", 1},
{"@GPT-4.", 1},
{"@GPT-4!", 1},
{"@GPT-4? help", 1},
{"(@GPT-4)", 0}, // ( before @ is not whitespace — not a mention
{"( @GPT-4)", 1}, // space before @ — valid mention, ) stripped
}
for _, tt := range tests {
m := Parse(tt.input, roster())
resolved := 0
for _, mm := range m {
if mm.Resolved != nil {
resolved++
}
}
if resolved != tt.want {
t.Errorf("Parse(%q): expected %d resolved, got %d", tt.input, tt.want, resolved)
}
}
}
func TestResolvedModels_Dedup(t *testing.T) {
m := Parse("@GPT-4 do this @GPT-4 and that", roster())
resolved := ResolvedModels(m)
if len(resolved) != 1 {
t.Fatalf("expected 1 deduplicated model, got %d", len(resolved))
}
}
func TestResolvedModels_NilOnNoResolve(t *testing.T) {
m := Parse("@unknown-model test", roster())
resolved := ResolvedModels(m)
if resolved != nil {
t.Fatalf("expected nil for unresolved only, got %d", len(resolved))
}
}
func TestResolvedModels_MultipleDistinct(t *testing.T) {
m := Parse("@GPT-4 and @Claude-3-Opus compare", roster())
resolved := ResolvedModels(m)
if len(resolved) != 2 {
t.Fatalf("expected 2 distinct models, got %d", len(resolved))
}
}
func TestNormalize(t *testing.T) {
tests := []struct {
in, want string
}{
{"Claude-3-Opus", "claude 3 opus"},
{"GPT-4", "gpt 4"},
{"gpt_4", "gpt 4"},
{" mixed--Case__Name ", "mixed case name"},
}
for _, tt := range tests {
got := normalize(tt.in)
if got != tt.want {
t.Errorf("normalize(%q) = %q, want %q", tt.in, got, tt.want)
}
}
}

40
server/models/models_notification.go Normal file
View File

@@ -0,0 +1,40 @@
package models
import "time"
// =========================================
// NOTIFICATIONS (v0.20.0)
// =========================================
// Notification represents an in-app notification for a user.
// Notifications are immutable once created — only is_read can be toggled.
type Notification struct {
ID string `json:"id" db:"id"`
UserID string `json:"user_id" db:"user_id"`
Type string `json:"type" db:"type"` // domain.action, e.g. "role.fallback", "kb.ready"
Title string `json:"title" db:"title"` // short summary shown in bell dropdown
Body string `json:"body,omitempty" db:"body"` // optional detail text
ResourceType string `json:"resource_type,omitempty" db:"resource_type"` // "channel", "knowledge_base", "project", etc.
ResourceID string `json:"resource_id,omitempty" db:"resource_id"` // navigable entity ID (no FK — resource may be deleted)
IsRead bool `json:"is_read" db:"is_read"`
CreatedAt time.Time `json:"created_at" db:"created_at"`
}
// Notification type constants. Convention: domain.action.
// Free-form strings — new types don't require migration.
const (
NotifTypeRoleFallback = "role.fallback"
NotifTypeKBReady = "kb.ready"
NotifTypeKBError = "kb.error"
NotifTypeGrantChanged = "grant.changed"
NotifTypeProjectInvite = "project.invite"
)
// Resource type constants for click-to-navigate.
// Note: ResourceTypeKnowledgeBase is already declared in models.go (resource_grants).
const (
ResourceTypeChannel = "channel"
ResourceTypeProject = "project"
ResourceTypeTeam = "team"
ResourceTypeGroup = "group"
)

20
server/models/models_notification_pref.go Normal file
View File

@@ -0,0 +1,20 @@
package models
// NotificationPreference stores a user's per-type notification delivery preference.
// Type "*" acts as a catch-all default for types without an explicit row.
type NotificationPreference struct {
ID string `json:"id" db:"id"`
UserID string `json:"user_id" db:"user_id"`
Type string `json:"type" db:"type"` // notification type or "*"
InApp bool `json:"in_app" db:"in_app"` // show in-app bell/panel
Email bool `json:"email" db:"email"` // send email
}
// ResolvedPreference is the effective preference after resolution chain.
type ResolvedPreference struct {
InApp bool
Email bool
}
// SystemDefaultPreference is the fallback when no user preference exists.
var SystemDefaultPreference = ResolvedPreference{InApp: true, Email: false}

198
server/notifications/email.go Normal file
View File

@@ -0,0 +1,198 @@
package notifications
import (
"context"
"crypto/tls"
"fmt"
"log"
"net"
"net/smtp"
"strings"
"time"
"git.gobha.me/xcaliber/chat-switchboard/store"
)
// SMTPConfig holds SMTP connection settings, loaded from platform_settings.
type SMTPConfig struct {
Host string `json:"smtp_host"`
Port int `json:"smtp_port"`
User string `json:"smtp_user"`
Password string `json:"smtp_password"` // decrypted at load time
From string `json:"smtp_from"`
TLS bool `json:"smtp_tls"`
}
// EmailTransport sends notification emails via SMTP.
type EmailTransport struct {
config SMTPConfig
}
// NewEmailTransport creates an email transport. Returns nil if config is invalid.
func NewEmailTransport(cfg SMTPConfig) *EmailTransport {
if cfg.Host == "" || cfg.Port == 0 || cfg.From == "" {
return nil
}
return &EmailTransport{config: cfg}
}
// Send delivers an email with both HTML and plaintext bodies.
// Uses multipart/alternative MIME for email client compatibility.
func (t *EmailTransport) Send(ctx context.Context, to, subject, htmlBody, textBody string) error {
if to == "" {
return fmt.Errorf("recipient email is empty")
}
addr := fmt.Sprintf("%s:%d", t.config.Host, t.config.Port)
boundary := fmt.Sprintf("==boundary_%d==", time.Now().UnixNano())
// Build MIME message
var msg strings.Builder
msg.WriteString(fmt.Sprintf("From: %s\r\n", t.config.From))
msg.WriteString(fmt.Sprintf("To: %s\r\n", to))
msg.WriteString(fmt.Sprintf("Subject: %s\r\n", subject))
msg.WriteString("MIME-Version: 1.0\r\n")
msg.WriteString(fmt.Sprintf("Content-Type: multipart/alternative; boundary=\"%s\"\r\n", boundary))
msg.WriteString("\r\n")
// Plaintext part
msg.WriteString(fmt.Sprintf("--%s\r\n", boundary))
msg.WriteString("Content-Type: text/plain; charset=UTF-8\r\n\r\n")
msg.WriteString(textBody)
msg.WriteString("\r\n")
// HTML part
msg.WriteString(fmt.Sprintf("--%s\r\n", boundary))
msg.WriteString("Content-Type: text/html; charset=UTF-8\r\n\r\n")
msg.WriteString(htmlBody)
msg.WriteString("\r\n")
msg.WriteString(fmt.Sprintf("--%s--\r\n", boundary))
// Connect with timeout
dialer := net.Dialer{Timeout: 10 * time.Second}
conn, err := dialer.DialContext(ctx, "tcp", addr)
if err != nil {
return fmt.Errorf("smtp dial: %w", err)
}
var client *smtp.Client
if t.config.TLS {
// Implicit TLS (port 465)
tlsConn := tls.Client(conn, &tls.Config{ServerName: t.config.Host})
client, err = smtp.NewClient(tlsConn, t.config.Host)
} else {
client, err = smtp.NewClient(conn, t.config.Host)
}
if err != nil {
conn.Close()
return fmt.Errorf("smtp client: %w", err)
}
defer client.Close()
// STARTTLS for non-implicit TLS on port 587
if !t.config.TLS {
if ok, _ := client.Extension("STARTTLS"); ok {
if err := client.StartTLS(&tls.Config{ServerName: t.config.Host}); err != nil {
return fmt.Errorf("smtp starttls: %w", err)
}
}
}
// Authenticate if credentials provided
if t.config.User != "" && t.config.Password != "" {
auth := smtp.PlainAuth("", t.config.User, t.config.Password, t.config.Host)
if err := client.Auth(auth); err != nil {
return fmt.Errorf("smtp auth: %w", err)
}
}
// Send
if err := client.Mail(t.config.From); err != nil {
return fmt.Errorf("smtp MAIL: %w", err)
}
if err := client.Rcpt(to); err != nil {
return fmt.Errorf("smtp RCPT: %w", err)
}
w, err := client.Data()
if err != nil {
return fmt.Errorf("smtp DATA: %w", err)
}
if _, err := w.Write([]byte(msg.String())); err != nil {
return fmt.Errorf("smtp write: %w", err)
}
if err := w.Close(); err != nil {
return fmt.Errorf("smtp close data: %w", err)
}
return client.Quit()
}
// SendAsync wraps Send in a goroutine so notification delivery isn't blocked.
func (t *EmailTransport) SendAsync(to, subject, htmlBody, textBody string) {
go func() {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
if err := t.Send(ctx, to, subject, htmlBody, textBody); err != nil {
log.Printf("[email] failed to send to %s: %v", to, err)
}
}()
}
// LoadSMTPConfig reads SMTP settings from global config and returns an SMTPConfig.
// Returns nil if email is not enabled or config is missing.
// The vault parameter is optional; if provided, it decrypts the SMTP password.
func LoadSMTPConfig(gc store.GlobalConfigStore, vault interface{}) (*SMTPConfig, error) {
raw, err := gc.Get(context.Background(), "notifications")
if err != nil {
return nil, fmt.Errorf("no notification settings: %w", err)
}
// Check if email is enabled
enabled, _ := raw["email_enabled"].(bool)
if !enabled {
return nil, nil
}
cfg := SMTPConfig{
Host: stringVal(raw, "smtp_host"),
Port: intVal(raw, "smtp_port", 587),
User: stringVal(raw, "smtp_user"),
From: stringVal(raw, "smtp_from"),
TLS: boolVal(raw, "smtp_tls"),
}
// Password: try decrypted value first, then raw
cfg.Password = stringVal(raw, "smtp_password")
if cfg.Host == "" {
return nil, fmt.Errorf("smtp_host is required")
}
if cfg.From == "" {
return nil, fmt.Errorf("smtp_from is required")
}
return &cfg, nil
}
func stringVal(m map[string]interface{}, key string) string {
if v, ok := m[key].(string); ok {
return v
}
return ""
}
func intVal(m map[string]interface{}, key string, def int) int {
switch v := m[key].(type) {
case float64:
return int(v)
case int:
return v
}
return def
}
func boolVal(m map[string]interface{}, key string) bool {
v, _ := m[key].(bool)
return v
}

203
server/notifications/service.go Normal file
View File

@@ -0,0 +1,203 @@
package notifications
import (
"context"
"encoding/json"
"log"
"sync"
"time"
"git.gobha.me/xcaliber/chat-switchboard/events"
"git.gobha.me/xcaliber/chat-switchboard/models"
"git.gobha.me/xcaliber/chat-switchboard/store"
)
// ── Package-level singleton ─────────────────
// Allows notification sources (KB ingester, group handler, etc.)
// to access the service without threading it through constructors.
var defaultService *Service
// SetDefault registers the global notification service instance.
// Called once at startup from main.go.
func SetDefault(svc *Service) {
defaultService = svc
}
// Default returns the global notification service instance, or nil if
// not configured (e.g. in unmanaged mode without a database).
func Default() *Service {
return defaultService
}
// Service handles notification creation, persistence, and real-time delivery.
// All notification sources should go through this service — never insert directly.
type Service struct {
store store.NotificationStore
prefStore store.NotificationPreferenceStore
userStore store.UserStore
hub *events.Hub
// Email transport (nil = email disabled)
email *EmailTransport
instanceName string
// Retention cleanup
retentionDays int
stopCleanup chan struct{}
cleanupWg sync.WaitGroup
}
// NewService creates a notification service bound to the given store and WebSocket hub.
func NewService(s store.NotificationStore, hub *events.Hub) *Service {
return &Service{
store: s,
hub: hub,
instanceName: "Chat Switchboard",
retentionDays: 90,
stopCleanup: make(chan struct{}),
}
}
// WithPrefs attaches the preference store for per-user delivery control.
func (s *Service) WithPrefs(ps store.NotificationPreferenceStore) *Service {
s.prefStore = ps
return s
}
// WithUsers attaches the user store for email address lookup.
func (s *Service) WithUsers(us store.UserStore) *Service {
s.userStore = us
return s
}
// WithEmail enables email transport.
func (s *Service) WithEmail(transport *EmailTransport, instanceName string) *Service {
s.email = transport
if instanceName != "" {
s.instanceName = instanceName
}
return s
}
// WithRetention sets the retention period in days. Notifications older than
// this are pruned by the background cleanup goroutine. Default: 90 days.
func (s *Service) WithRetention(days int) *Service {
if days > 0 {
s.retentionDays = days
}
return s
}
// Notify routes a notification through the user's delivery preferences:
// in-app (persist + WebSocket) and/or email. Falls back to system defaults
// if no user preferences are set.
func (s *Service) Notify(ctx context.Context, n *models.Notification) error {
prefs := s.resolvePrefs(ctx, n.UserID, n.Type)
// In-app: persist + WebSocket push
if prefs.InApp {
if err := s.store.Create(ctx, n); err != nil {
return err
}
if s.hub != nil {
payload, _ := json.Marshal(n)
s.hub.SendToUser(n.UserID, events.Event{
Label: "notification.new",
Payload: payload,
Ts: time.Now().UnixMilli(),
})
}
}
// Email: async send (don't block the caller)
if prefs.Email && s.email != nil && s.userStore != nil {
user, err := s.userStore.GetByID(ctx, n.UserID)
if err == nil && user != nil && user.Email != "" {
subject := SubjectForNotification(n, s.instanceName)
htmlBody := RenderHTML(n, s.instanceName)
textBody := RenderText(n, s.instanceName)
s.email.SendAsync(user.Email, subject, htmlBody, textBody)
}
}
return nil
}
// NotifyMany fans out a notification template to multiple users.
// Each user gets their own copy. Errors are logged but don't fail the batch.
func (s *Service) NotifyMany(ctx context.Context, userIDs []string, template models.Notification) {
for _, uid := range userIDs {
n := template
n.ID = "" // let store generate
n.UserID = uid
if err := s.Notify(ctx, &n); err != nil {
log.Printf("[notifications] failed to notify user %s: %v", uid, err)
}
}
}
// resolvePrefs returns the effective delivery preferences for a user + type.
// Resolution chain: specific type → user '*' default → system default.
func (s *Service) resolvePrefs(ctx context.Context, userID, notifType string) models.ResolvedPreference {
if s.prefStore == nil {
return models.SystemDefaultPreference
}
// 1. Specific type preference
pref, err := s.prefStore.Get(ctx, userID, notifType)
if err == nil && pref != nil {
return models.ResolvedPreference{InApp: pref.InApp, Email: pref.Email}
}
// 2. User's wildcard default
pref, err = s.prefStore.Get(ctx, userID, "*")
if err == nil && pref != nil {
return models.ResolvedPreference{InApp: pref.InApp, Email: pref.Email}
}
// 3. System default
return models.SystemDefaultPreference
}
// StartCleanup launches a background goroutine that prunes old notifications daily.
func (s *Service) StartCleanup() {
s.cleanupWg.Add(1)
go func() {
defer s.cleanupWg.Done()
ticker := time.NewTicker(24 * time.Hour)
defer ticker.Stop()
// Run once on startup (after a short delay to avoid contention)
time.Sleep(5 * time.Minute)
s.runCleanup()
for {
select {
case <-ticker.C:
s.runCleanup()
case <-s.stopCleanup:
return
}
}
}()
}
// StopCleanup signals the cleanup goroutine to stop and waits for it.
func (s *Service) StopCleanup() {
close(s.stopCleanup)
s.cleanupWg.Wait()
}
func (s *Service) runCleanup() {
cutoff := time.Now().AddDate(0, 0, -s.retentionDays)
deleted, err := s.store.DeleteOlderThan(context.Background(), cutoff)
if err != nil {
log.Printf("[notifications] cleanup error: %v", err)
return
}
if deleted > 0 {
log.Printf("[notifications] cleaned up %d notifications older than %d days", deleted, s.retentionDays)
}
}

137
server/notifications/service_test.go Normal file
View File

@@ -0,0 +1,137 @@
package notifications
import (
"context"
"testing"
"git.gobha.me/xcaliber/chat-switchboard/models"
)
// mockPrefStore implements store.NotificationPreferenceStore for testing.
type mockPrefStore struct {
prefs map[string]map[string]*models.NotificationPreference // userID → type → pref
}
func newMockPrefStore() *mockPrefStore {
return &mockPrefStore{prefs: make(map[string]map[string]*models.NotificationPreference)}
}
func (m *mockPrefStore) Get(_ context.Context, userID, notifType string) (*models.NotificationPreference, error) {
if userPrefs, ok := m.prefs[userID]; ok {
if p, ok := userPrefs[notifType]; ok {
return p, nil
}
}
return nil, nil
}
func (m *mockPrefStore) ListForUser(_ context.Context, userID string) ([]models.NotificationPreference, error) {
var result []models.NotificationPreference
if userPrefs, ok := m.prefs[userID]; ok {
for _, p := range userPrefs {
result = append(result, *p)
}
}
return result, nil
}
func (m *mockPrefStore) Upsert(_ context.Context, pref *models.NotificationPreference) error {
if m.prefs[pref.UserID] == nil {
m.prefs[pref.UserID] = make(map[string]*models.NotificationPreference)
}
m.prefs[pref.UserID][pref.Type] = pref
return nil
}
func (m *mockPrefStore) Delete(_ context.Context, userID, notifType string) error {
if userPrefs, ok := m.prefs[userID]; ok {
delete(userPrefs, notifType)
}
return nil
}
func (m *mockPrefStore) set(userID, notifType string, inApp, email bool) {
if m.prefs[userID] == nil {
m.prefs[userID] = make(map[string]*models.NotificationPreference)
}
m.prefs[userID][notifType] = &models.NotificationPreference{
UserID: userID,
Type: notifType,
InApp: inApp,
Email: email,
}
}
func TestResolvePrefs_SystemDefault(t *testing.T) {
svc := &Service{prefStore: newMockPrefStore()}
p := svc.resolvePrefs(context.Background(), "user1", "kb.ready")
if !p.InApp || p.Email {
t.Errorf("expected system default (in_app=true, email=false), got %+v", p)
}
}
func TestResolvePrefs_NoPrefStore(t *testing.T) {
svc := &Service{prefStore: nil}
p := svc.resolvePrefs(context.Background(), "user1", "kb.ready")
if !p.InApp || p.Email {
t.Errorf("expected system default when no pref store, got %+v", p)
}
}
func TestResolvePrefs_SpecificType(t *testing.T) {
ps := newMockPrefStore()
ps.set("user1", "kb.ready", true, true)
svc := &Service{prefStore: ps}
p := svc.resolvePrefs(context.Background(), "user1", "kb.ready")
if !p.InApp || !p.Email {
t.Errorf("expected specific pref (in_app=true, email=true), got %+v", p)
}
}
func TestResolvePrefs_WildcardFallback(t *testing.T) {
ps := newMockPrefStore()
ps.set("user1", "*", false, true) // user turned off in-app, turned on email globally
svc := &Service{prefStore: ps}
// No specific "kb.ready" pref → falls to wildcard
p := svc.resolvePrefs(context.Background(), "user1", "kb.ready")
if p.InApp || !p.Email {
t.Errorf("expected wildcard pref (in_app=false, email=true), got %+v", p)
}
}
func TestResolvePrefs_SpecificOverridesWildcard(t *testing.T) {
ps := newMockPrefStore()
ps.set("user1", "*", false, true) // wildcard: no in-app, yes email
ps.set("user1", "kb.ready", true, false) // specific: yes in-app, no email
svc := &Service{prefStore: ps}
p := svc.resolvePrefs(context.Background(), "user1", "kb.ready")
if !p.InApp || p.Email {
t.Errorf("specific should override wildcard, got %+v", p)
}
}
func TestResolvePrefs_DifferentUsersIsolated(t *testing.T) {
ps := newMockPrefStore()
ps.set("user1", "kb.ready", false, true)
svc := &Service{prefStore: ps}
// user2 has no prefs → system default
p := svc.resolvePrefs(context.Background(), "user2", "kb.ready")
if !p.InApp || p.Email {
t.Errorf("user2 should get system default, got %+v", p)
}
}
func TestResolvePrefs_DisableBoth(t *testing.T) {
ps := newMockPrefStore()
ps.set("user1", "kb.ready", false, false)
svc := &Service{prefStore: ps}
p := svc.resolvePrefs(context.Background(), "user1", "kb.ready")
if p.InApp || p.Email {
t.Errorf("expected both disabled, got %+v", p)
}
}

146
server/notifications/sources.go Normal file
View File

@@ -0,0 +1,146 @@
package notifications
import (
"context"
"encoding/json"
"fmt"
"log"
"git.gobha.me/xcaliber/chat-switchboard/events"
"git.gobha.me/xcaliber/chat-switchboard/models"
"git.gobha.me/xcaliber/chat-switchboard/store"
)
// ── Role Fallback ───────────────────────────
// Subscribes to the existing "role.fallback" EventBus event (emitted by
// capabilities/resolver.go since v0.17.0) and creates notifications for
// all admin users.
// roleFallbackPayload matches the payload emitted by the role resolver.
type roleFallbackPayload struct {
Role string `json:"role"`
Primary string `json:"primary_model"`
Fallback string `json:"fallback_model"`
Error string `json:"error"`
}
// RoleFallbackHandler returns an events.Handler that creates admin
// notifications when a model role falls back.
func RoleFallbackHandler(svc *Service, stores store.Stores) events.Handler {
return func(e events.Event) {
var p roleFallbackPayload
if err := json.Unmarshal(e.Payload, &p); err != nil {
log.Printf("[notifications] failed to parse role.fallback payload: %v", err)
return
}
title := fmt.Sprintf("Model fallback: %s → %s", p.Primary, p.Fallback)
if p.Primary == "" {
title = fmt.Sprintf("Role '%s' fell back to %s", p.Role, p.Fallback)
}
body := ""
if p.Error != "" {
body = fmt.Sprintf("Primary model error: %s", p.Error)
}
// Notify all admin users
ctx := context.Background()
admins, _, err := stores.Users.List(ctx, store.ListOptions{Limit: 500})
if err != nil {
log.Printf("[notifications] failed to list users for role.fallback: %v", err)
return
}
for _, u := range admins {
if u.Role != "admin" {
continue
}
n := models.Notification{
UserID: u.ID,
Type: models.NotifTypeRoleFallback,
Title: title,
Body: body,
}
if err := svc.Notify(ctx, &n); err != nil {
log.Printf("[notifications] failed to create role.fallback notification for %s: %v", u.ID, err)
}
}
}
}
// ── Knowledge Base ──────────────────────────
// Called directly from the KB handler after indexing completes or fails.
// Not a bus subscriber — the KB handler calls these functions.
// NotifyKBReady creates a notification when a knowledge base finishes indexing.
func NotifyKBReady(svc *Service, userID, kbID, kbName string, chunkCount int) {
if svc == nil {
return
}
n := models.Notification{
UserID: userID,
Type: models.NotifTypeKBReady,
Title: fmt.Sprintf("Knowledge base \"%s\" ready (%d chunks)", kbName, chunkCount),
ResourceType: models.ResourceTypeKnowledgeBase,
ResourceID: kbID,
}
if err := svc.Notify(context.Background(), &n); err != nil {
log.Printf("[notifications] kb.ready failed for user %s: %v", userID, err)
}
}
// NotifyKBError creates a notification when KB indexing fails.
func NotifyKBError(svc *Service, userID, kbID, kbName, errMsg string) {
if svc == nil {
return
}
n := models.Notification{
UserID: userID,
Type: models.NotifTypeKBError,
Title: fmt.Sprintf("Knowledge base \"%s\" indexing failed", kbName),
Body: errMsg,
ResourceType: models.ResourceTypeKnowledgeBase,
ResourceID: kbID,
}
if err := svc.Notify(context.Background(), &n); err != nil {
log.Printf("[notifications] kb.error failed for user %s: %v", userID, err)
}
}
// ── Group Membership ────────────────────────
// Called directly from the group handler on add/remove.
// NotifyGroupMemberAdded creates a notification when a user is added to a group.
func NotifyGroupMemberAdded(svc *Service, userID, groupID, groupName string) {
if svc == nil {
return
}
n := models.Notification{
UserID: userID,
Type: models.NotifTypeGrantChanged,
Title: fmt.Sprintf("You were added to group \"%s\"", groupName),
ResourceType: models.ResourceTypeGroup,
ResourceID: groupID,
}
if err := svc.Notify(context.Background(), &n); err != nil {
log.Printf("[notifications] grant.changed (add) failed for user %s: %v", userID, err)
}
}
// NotifyGroupMemberRemoved creates a notification when a user is removed from a group.
func NotifyGroupMemberRemoved(svc *Service, userID, groupID, groupName string) {
if svc == nil {
return
}
n := models.Notification{
UserID: userID,
Type: models.NotifTypeGrantChanged,
Title: fmt.Sprintf("You were removed from group \"%s\"", groupName),
ResourceType: models.ResourceTypeGroup,
ResourceID: groupID,
}
if err := svc.Notify(context.Background(), &n); err != nil {
log.Printf("[notifications] grant.changed (remove) failed for user %s: %v", userID, err)
}
}

108
server/notifications/templates.go Normal file
View File

@@ -0,0 +1,108 @@
package notifications
import (
"bytes"
"html/template"
"strings"
"git.gobha.me/xcaliber/chat-switchboard/models"
)
// ── Template Data ───────────────────────────
type emailData struct {
Title string
Body string
Type string
ResourceType string
InstanceName string
}
// ── HTML Template ───────────────────────────
var htmlTmpl = template.Must(template.New("email").Parse(`<!DOCTYPE html>
<html>
<head><meta charset="UTF-8"></head>
<body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px; color: #333;">
<div style="border-bottom: 2px solid #4a8af4; padding-bottom: 12px; margin-bottom: 20px;">
<h2 style="margin: 0; color: #4a8af4;">{{.InstanceName}}</h2>
</div>
<div style="background: #f8f9fa; border-radius: 8px; padding: 16px; margin-bottom: 16px;">
<h3 style="margin: 0 0 8px;">{{.Title}}</h3>
{{if .Body}}<p style="margin: 0; color: #555;">{{.Body}}</p>{{end}}
</div>
<p style="font-size: 0.85em; color: #999;">
This notification was sent by {{.InstanceName}}. You can adjust your notification preferences in Settings.
</p>
</body>
</html>`))
// ── Plaintext Template ──────────────────────
var textTmpl = template.Must(template.New("email_text").Parse(`{{.InstanceName}} — Notification
{{.Title}}
{{if .Body}}
{{.Body}}
{{end}}
---
Adjust your notification preferences in Settings.
`))
// ── Render Functions ────────────────────────
// RenderHTML renders an HTML email body for a notification.
func RenderHTML(n *models.Notification, instanceName string) string {
if instanceName == "" {
instanceName = "Chat Switchboard"
}
data := emailData{
Title: n.Title,
Body: n.Body,
Type: n.Type,
ResourceType: n.ResourceType,
InstanceName: instanceName,
}
var buf bytes.Buffer
if err := htmlTmpl.Execute(&buf, data); err != nil {
return "<p>" + template.HTMLEscapeString(n.Title) + "</p>"
}
return buf.String()
}
// RenderText renders a plaintext email body for a notification.
func RenderText(n *models.Notification, instanceName string) string {
if instanceName == "" {
instanceName = "Chat Switchboard"
}
data := emailData{
Title: n.Title,
Body: n.Body,
Type: n.Type,
ResourceType: n.ResourceType,
InstanceName: instanceName,
}
var buf bytes.Buffer
if err := textTmpl.Execute(&buf, data); err != nil {
return n.Title
}
return buf.String()
}
// SubjectForNotification returns an email subject line.
func SubjectForNotification(n *models.Notification, instanceName string) string {
if instanceName == "" {
instanceName = "Chat Switchboard"
}
prefix := "[" + instanceName + "] "
switch {
case strings.HasPrefix(n.Type, "kb."):
return prefix + "Knowledge Base: " + n.Title
case strings.HasPrefix(n.Type, "role."):
return prefix + "Model Alert: " + n.Title
case strings.HasPrefix(n.Type, "grant."):
return prefix + "Access Change: " + n.Title
default:
return prefix + n.Title
}
}

69
server/notifications/templates_test.go Normal file
View File

@@ -0,0 +1,69 @@
package notifications
import (
"strings"
"testing"
"git.gobha.me/xcaliber/chat-switchboard/models"
)
func TestRenderHTML_Basic(t *testing.T) {
n := &models.Notification{
Title: "KB Ready",
Body: "Your knowledge base has been processed.",
Type: "kb.ready",
}
html := RenderHTML(n, "TestInstance")
if !strings.Contains(html, "KB Ready") {
t.Error("expected title in HTML output")
}
if !strings.Contains(html, "TestInstance") {
t.Error("expected instance name in HTML output")
}
if !strings.Contains(html, "knowledge base") {
t.Error("expected body in HTML output")
}
}
func TestRenderHTML_DefaultInstanceName(t *testing.T) {
n := &models.Notification{Title: "Test"}
html := RenderHTML(n, "")
if !strings.Contains(html, "Chat Switchboard") {
t.Error("expected default instance name")
}
}
func TestRenderText_Basic(t *testing.T) {
n := &models.Notification{
Title: "Model Fallback",
Body: "GPT-4 fell back to GPT-3.5.",
Type: "role.fallback",
}
text := RenderText(n, "MyInstance")
if !strings.Contains(text, "Model Fallback") {
t.Error("expected title in text output")
}
if !strings.Contains(text, "GPT-4 fell back") {
t.Error("expected body in text output")
}
}
func TestSubjectForNotification(t *testing.T) {
tests := []struct {
notifType string
title string
want string
}{
{"kb.ready", "KB Processed", "[Test] Knowledge Base: KB Processed"},
{"role.fallback", "Fallback", "[Test] Model Alert: Fallback"},
{"grant.changed", "Added to team", "[Test] Access Change: Added to team"},
{"custom.type", "Hello", "[Test] Hello"},
}
for _, tt := range tests {
n := &models.Notification{Type: tt.notifType, Title: tt.title}
got := SubjectForNotification(n, "Test")
if got != tt.want {
t.Errorf("SubjectForNotification(%q, %q) = %q, want %q", tt.notifType, tt.title, got, tt.want)
}
}
}

34
server/store/interfaces.go
View File

@@ -40,6 +40,8 @@ type Stores struct {
ResourceGrants ResourceGrantStore
Memories MemoryStore
Projects ProjectStore
Notifications NotificationStore
NotifPrefs NotificationPreferenceStore
}
// =========================================
@@ -216,6 +218,9 @@ type ChannelStore interface {
// Channel models
SetModel(ctx context.Context, cm *models.ChannelModel) error
GetModels(ctx context.Context, channelID string) ([]models.ChannelModel, error)
GetModelByID(ctx context.Context, id string) (*models.ChannelModel, error)
UpdateModel(ctx context.Context, id string, fields map[string]interface{}) error
DeleteModel(ctx context.Context, id string) error
// Ownership check
UserOwns(ctx context.Context, channelID, userID string) (bool, error)
@@ -476,6 +481,35 @@ type ResourceGrantStore interface {
UserHasGroupAccess(ctx context.Context, userID, resourceType, resourceID string) (bool, error)
}
// =========================================
// NOTIFICATION STORE (v0.20.0)
// =========================================
type NotificationStore interface {
Create(ctx context.Context, n *models.Notification) error
ListByUser(ctx context.Context, userID string, limit, offset int, unreadOnly bool) ([]models.Notification, int, error)
MarkRead(ctx context.Context, id, userID string) error
MarkAllRead(ctx context.Context, userID string) error
Delete(ctx context.Context, id, userID string) error
UnreadCount(ctx context.Context, userID string) (int, error)
DeleteOlderThan(ctx context.Context, before time.Time) (int64, error)
}
// =========================================
// NOTIFICATION PREFERENCES STORE (v0.20.0)
// =========================================
type NotificationPreferenceStore interface {
// Get returns the preference for a specific user + type. Returns nil if not set.
Get(ctx context.Context, userID, notifType string) (*models.NotificationPreference, error)
// ListForUser returns all preferences set by a user.
ListForUser(ctx context.Context, userID string) ([]models.NotificationPreference, error)
// Upsert creates or updates a preference row.
Upsert(ctx context.Context, pref *models.NotificationPreference) error
// Delete removes a preference (falls back to default).
Delete(ctx context.Context, userID, notifType string) error
}
// =========================================
// SHARED TYPES
// =========================================

47
server/store/postgres/channel.go
View File

@@ -4,6 +4,8 @@ import (
"context"
"database/sql"
"encoding/json"
"fmt"
"strings"
"git.gobha.me/xcaliber/chat-switchboard/models"
"git.gobha.me/xcaliber/chat-switchboard/store"
@@ -212,6 +214,51 @@ func (s *ChannelStore) GetModels(ctx context.Context, channelID string) ([]model
return result, rows.Err()
}
func (s *ChannelStore) GetModelByID(ctx context.Context, id string) (*models.ChannelModel, error) {
var cm models.ChannelModel
err := DB.QueryRowContext(ctx, `
SELECT id, channel_id, model_id, COALESCE(provider_config_id::text, ''),
COALESCE(display_name, ''), COALESCE(system_prompt, ''), is_default
FROM channel_models WHERE id = $1`, id).Scan(
&cm.ID, &cm.ChannelID, &cm.ModelID, &cm.ProviderConfigID,
&cm.DisplayName, &cm.SystemPrompt, &cm.IsDefault)
if err != nil {
return nil, err
}
return &cm, nil
}
func (s *ChannelStore) UpdateModel(ctx context.Context, id string, fields map[string]interface{}) error {
if len(fields) == 0 {
return nil
}
// Build SET clause dynamically
sets := make([]string, 0, len(fields))
args := make([]interface{}, 0, len(fields)+1)
i := 1
for col, val := range fields {
sets = append(sets, col+" = $"+fmt.Sprintf("%d", i))
args = append(args, val)
i++
}
args = append(args, id)
query := "UPDATE channel_models SET " + strings.Join(sets, ", ") + " WHERE id = $" + fmt.Sprintf("%d", i)
_, err := DB.ExecContext(ctx, query, args...)
return err
}
func (s *ChannelStore) DeleteModel(ctx context.Context, id string) error {
res, err := DB.ExecContext(ctx, `DELETE FROM channel_models WHERE id = $1`, id)
if err != nil {
return err
}
n, _ := res.RowsAffected()
if n == 0 {
return sql.ErrNoRows
}
return nil
}
func (s *ChannelStore) UserOwns(ctx context.Context, channelID, userID string) (bool, error) {
var exists bool
err := DB.QueryRowContext(ctx,

133
server/store/postgres/notification.go Normal file
View File

@@ -0,0 +1,133 @@
package postgres
import (
"context"
"database/sql"
"time"
"git.gobha.me/xcaliber/chat-switchboard/models"
)
type NotificationStore struct{}
func NewNotificationStore() *NotificationStore { return &NotificationStore{} }
func (s *NotificationStore) Create(ctx context.Context, n *models.Notification) error {
return DB.QueryRowContext(ctx, `
INSERT INTO notifications (user_id, type, title, body, resource_type, resource_id, is_read)
VALUES ($1, $2, $3, $4, $5, $6, $7)
RETURNING id, created_at`,
n.UserID, n.Type, n.Title, n.Body,
nullStr(n.ResourceType), nullStr(n.ResourceID), n.IsRead,
).Scan(&n.ID, &n.CreatedAt)
}
func (s *NotificationStore) ListByUser(ctx context.Context, userID string, limit, offset int, unreadOnly bool) ([]models.Notification, int, error) {
if limit <= 0 {
limit = 20
}
// Count
countQ := `SELECT COUNT(*) FROM notifications WHERE user_id = $1`
args := []interface{}{userID}
if unreadOnly {
countQ += ` AND is_read = false`
}
var total int
if err := DB.QueryRowContext(ctx, countQ, args...).Scan(&total); err != nil {
return nil, 0, err
}
// Fetch
q := `SELECT id, user_id, type, title, body, resource_type, resource_id, is_read, created_at
FROM notifications WHERE user_id = $1`
if unreadOnly {
q += ` AND is_read = false`
}
q += ` ORDER BY created_at DESC LIMIT $2 OFFSET $3`
rows, err := DB.QueryContext(ctx, q, userID, limit, offset)
if err != nil {
return nil, 0, err
}
defer rows.Close()
var items []models.Notification
for rows.Next() {
var n models.Notification
var resType, resID sql.NullString
if err := rows.Scan(
&n.ID, &n.UserID, &n.Type, &n.Title, &n.Body,
&resType, &resID, &n.IsRead, &n.CreatedAt,
); err != nil {
return nil, 0, err
}
n.ResourceType = NullableString(resType)
n.ResourceID = NullableString(resID)
items = append(items, n)
}
if items == nil {
items = []models.Notification{}
}
return items, total, rows.Err()
}
func (s *NotificationStore) MarkRead(ctx context.Context, id, userID string) error {
res, err := DB.ExecContext(ctx,
`UPDATE notifications SET is_read = true WHERE id = $1 AND user_id = $2`,
id, userID)
if err != nil {
return err
}
n, _ := res.RowsAffected()
if n == 0 {
return sql.ErrNoRows
}
return nil
}
func (s *NotificationStore) MarkAllRead(ctx context.Context, userID string) error {
_, err := DB.ExecContext(ctx,
`UPDATE notifications SET is_read = true WHERE user_id = $1 AND is_read = false`,
userID)
return err
}
func (s *NotificationStore) Delete(ctx context.Context, id, userID string) error {
res, err := DB.ExecContext(ctx,
`DELETE FROM notifications WHERE id = $1 AND user_id = $2`, id, userID)
if err != nil {
return err
}
n, _ := res.RowsAffected()
if n == 0 {
return sql.ErrNoRows
}
return nil
}
func (s *NotificationStore) UnreadCount(ctx context.Context, userID string) (int, error) {
var count int
err := DB.QueryRowContext(ctx,
`SELECT COUNT(*) FROM notifications WHERE user_id = $1 AND is_read = false`,
userID).Scan(&count)
return count, err
}
func (s *NotificationStore) DeleteOlderThan(ctx context.Context, before time.Time) (int64, error) {
res, err := DB.ExecContext(ctx,
`DELETE FROM notifications WHERE created_at < $1`, before)
if err != nil {
return 0, err
}
return res.RowsAffected()
}
// nullStr returns sql.NullString for optional string fields.
func nullStr(s string) sql.NullString {
if s == "" {
return sql.NullString{}
}
return sql.NullString{String: s, Valid: true}
}

69
server/store/postgres/notification_prefs.go Normal file
View File

@@ -0,0 +1,69 @@
package postgres
import (
"context"
"database/sql"
"git.gobha.me/xcaliber/chat-switchboard/models"
)
type NotificationPreferenceStore struct{}
func NewNotificationPreferenceStore() *NotificationPreferenceStore {
return &NotificationPreferenceStore{}
}
func (s *NotificationPreferenceStore) Get(ctx context.Context, userID, notifType string) (*models.NotificationPreference, error) {
var p models.NotificationPreference
err := DB.QueryRowContext(ctx, `
SELECT id, user_id, type, in_app, email
FROM notification_preferences
WHERE user_id = $1 AND type = $2`, userID, notifType).Scan(
&p.ID, &p.UserID, &p.Type, &p.InApp, &p.Email)
if err == sql.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, err
}
return &p, nil
}
func (s *NotificationPreferenceStore) ListForUser(ctx context.Context, userID string) ([]models.NotificationPreference, error) {
rows, err := DB.QueryContext(ctx, `
SELECT id, user_id, type, in_app, email
FROM notification_preferences
WHERE user_id = $1
ORDER BY type`, userID)
if err != nil {
return nil, err
}
defer rows.Close()
var result []models.NotificationPreference
for rows.Next() {
var p models.NotificationPreference
if err := rows.Scan(&p.ID, &p.UserID, &p.Type, &p.InApp, &p.Email); err != nil {
return nil, err
}
result = append(result, p)
}
return result, rows.Err()
}
func (s *NotificationPreferenceStore) Upsert(ctx context.Context, pref *models.NotificationPreference) error {
_, err := DB.ExecContext(ctx, `
INSERT INTO notification_preferences (user_id, type, in_app, email)
VALUES ($1, $2, $3, $4)
ON CONFLICT (user_id, type) DO UPDATE SET
in_app = $3, email = $4`,
pref.UserID, pref.Type, pref.InApp, pref.Email)
return err
}
func (s *NotificationPreferenceStore) Delete(ctx context.Context, userID, notifType string) error {
_, err := DB.ExecContext(ctx, `
DELETE FROM notification_preferences
WHERE user_id = $1 AND type = $2`, userID, notifType)
return err
}

36
server/store/postgres/stores.go
View File

@@ -11,27 +11,29 @@ import (
func NewStores(db *sql.DB) store.Stores {
SetDB(db)
return store.Stores{
Providers: NewProviderStore(),
Catalog: NewCatalogStore(),
Personas: NewPersonaStore(),
Policies: NewPolicyStore(),
UserSettings: NewUserModelSettingsStore(),
Users: NewUserStore(),
Teams: NewTeamStore(),
Channels: NewChannelStore(),
Messages: NewMessageStore(),
Audit: NewAuditStore(),
Notes: NewNoteStore(),
NoteLinks: NewNoteLinkStore(),
GlobalConfig: NewGlobalConfigStore(),
Usage: NewUsageStore(),
Pricing: NewPricingStore(),
Extensions: NewExtensionStore(),
Attachments: NewAttachmentStore(),
Providers: NewProviderStore(),
Catalog: NewCatalogStore(),
Personas: NewPersonaStore(),
Policies: NewPolicyStore(),
UserSettings: NewUserModelSettingsStore(),
Users: NewUserStore(),
Teams: NewTeamStore(),
Channels: NewChannelStore(),
Messages: NewMessageStore(),
Audit: NewAuditStore(),
Notes: NewNoteStore(),
NoteLinks: NewNoteLinkStore(),
GlobalConfig: NewGlobalConfigStore(),
Usage: NewUsageStore(),
Pricing: NewPricingStore(),
Extensions: NewExtensionStore(),
Attachments: NewAttachmentStore(),
KnowledgeBases: NewKnowledgeBaseStore(),
Groups: NewGroupStore(),
ResourceGrants: NewResourceGrantStore(),
Memories: NewMemoryStore(),
Projects: NewProjectStore(),
Notifications: NewNotificationStore(),
NotifPrefs: NewNotificationPreferenceStore(),
}
}

6
server/store/postgres/user_settings.go
View File

@@ -14,8 +14,8 @@ func NewUserModelSettingsStore() *UserModelSettingsStore { return &UserModelSett
func (s *UserModelSettingsStore) GetForUser(ctx context.Context, userID string) ([]models.UserModelSetting, error) {
rows, err := DB.QueryContext(ctx, `
SELECT id, user_id, model_id, hidden, preferred_temperature, preferred_max_tokens,
sort_order, created_at, updated_at
SELECT id, user_id, model_id, COALESCE(hidden, false), preferred_temperature, preferred_max_tokens,
COALESCE(sort_order, 0), created_at, updated_at
FROM user_model_settings WHERE user_id = $1 ORDER BY sort_order, model_id`, userID)
if err != nil {
return nil, err
@@ -91,7 +91,7 @@ func (s *UserModelSettingsStore) Set(ctx context.Context, userID, modelID string
// Build a custom upsert since the update builder doesn't handle INSERT ON CONFLICT
_, err := DB.ExecContext(ctx, `
INSERT INTO user_model_settings (user_id, model_id, hidden, preferred_temperature, preferred_max_tokens, sort_order)
VALUES ($1, $2, $3, $4, $5, $6)
VALUES ($1, $2, COALESCE($3, false), $4, $5, COALESCE($6, 0))
ON CONFLICT (user_id, model_id)
DO UPDATE SET
hidden = COALESCE($3, user_model_settings.hidden),

43
server/store/sqlite/channel.go
View File

@@ -4,6 +4,7 @@ import (
"context"
"database/sql"
"encoding/json"
"strings"
"time"
"git.gobha.me/xcaliber/chat-switchboard/models"
@@ -218,6 +219,48 @@ func (s *ChannelStore) GetModels(ctx context.Context, channelID string) ([]model
return result, rows.Err()
}
func (s *ChannelStore) GetModelByID(ctx context.Context, id string) (*models.ChannelModel, error) {
var cm models.ChannelModel
err := DB.QueryRowContext(ctx, `
SELECT id, channel_id, model_id, COALESCE(provider_config_id, ''),
COALESCE(display_name, ''), COALESCE(system_prompt, ''), is_default
FROM channel_models WHERE id = ?`, id).Scan(
&cm.ID, &cm.ChannelID, &cm.ModelID, &cm.ProviderConfigID,
&cm.DisplayName, &cm.SystemPrompt, &cm.IsDefault)
if err != nil {
return nil, err
}
return &cm, nil
}
func (s *ChannelStore) UpdateModel(ctx context.Context, id string, fields map[string]interface{}) error {
if len(fields) == 0 {
return nil
}
sets := make([]string, 0, len(fields))
args := make([]interface{}, 0, len(fields)+1)
for col, val := range fields {
sets = append(sets, col+" = ?")
args = append(args, val)
}
args = append(args, id)
query := "UPDATE channel_models SET " + strings.Join(sets, ", ") + " WHERE id = ?"
_, err := DB.ExecContext(ctx, query, args...)
return err
}
func (s *ChannelStore) DeleteModel(ctx context.Context, id string) error {
res, err := DB.ExecContext(ctx, `DELETE FROM channel_models WHERE id = ?`, id)
if err != nil {
return err
}
n, _ := res.RowsAffected()
if n == 0 {
return sql.ErrNoRows
}
return nil
}
func (s *ChannelStore) UserOwns(ctx context.Context, channelID, userID string) (bool, error) {
var exists bool
err := DB.QueryRowContext(ctx,

146
server/store/sqlite/notification.go Normal file
View File

@@ -0,0 +1,146 @@
package sqlite
import (
"context"
"database/sql"
"time"
"git.gobha.me/xcaliber/chat-switchboard/models"
"git.gobha.me/xcaliber/chat-switchboard/store"
)
type NotificationStore struct{}
func NewNotificationStore() *NotificationStore { return &NotificationStore{} }
func (s *NotificationStore) Create(ctx context.Context, n *models.Notification) error {
if n.ID == "" {
n.ID = store.NewID()
}
now := time.Now().UTC().Format(timeFmt)
_, err := DB.ExecContext(ctx, `
INSERT INTO notifications (id, user_id, type, title, body, resource_type, resource_id, is_read, created_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
n.ID, n.UserID, n.Type, n.Title, n.Body,
nullStr(n.ResourceType), nullStr(n.ResourceID), boolToInt(n.IsRead), now,
)
if err != nil {
return err
}
n.CreatedAt, _ = time.Parse(timeFmt, now)
return nil
}
func (s *NotificationStore) ListByUser(ctx context.Context, userID string, limit, offset int, unreadOnly bool) ([]models.Notification, int, error) {
if limit <= 0 {
limit = 20
}
// Count
countQ := `SELECT COUNT(*) FROM notifications WHERE user_id = ?`
countArgs := []interface{}{userID}
if unreadOnly {
countQ += ` AND is_read = 0`
}
var total int
if err := DB.QueryRowContext(ctx, countQ, countArgs...).Scan(&total); err != nil {
return nil, 0, err
}
// Fetch
q := `SELECT id, user_id, type, title, body, resource_type, resource_id, is_read, created_at
FROM notifications WHERE user_id = ?`
if unreadOnly {
q += ` AND is_read = 0`
}
q += ` ORDER BY created_at DESC LIMIT ? OFFSET ?`
rows, err := DB.QueryContext(ctx, q, userID, limit, offset)
if err != nil {
return nil, 0, err
}
defer rows.Close()
var items []models.Notification
for rows.Next() {
var n models.Notification
var resType, resID sql.NullString
var isRead int
if err := rows.Scan(
&n.ID, &n.UserID, &n.Type, &n.Title, &n.Body,
&resType, &resID, &isRead, st(&n.CreatedAt),
); err != nil {
return nil, 0, err
}
n.ResourceType = NullableString(resType)
n.ResourceID = NullableString(resID)
n.IsRead = isRead != 0
items = append(items, n)
}
if items == nil {
items = []models.Notification{}
}
return items, total, rows.Err()
}
func (s *NotificationStore) MarkRead(ctx context.Context, id, userID string) error {
res, err := DB.ExecContext(ctx,
`UPDATE notifications SET is_read = 1 WHERE id = ? AND user_id = ?`,
id, userID)
if err != nil {
return err
}
n, _ := res.RowsAffected()
if n == 0 {
return sql.ErrNoRows
}
return nil
}
func (s *NotificationStore) MarkAllRead(ctx context.Context, userID string) error {
_, err := DB.ExecContext(ctx,
`UPDATE notifications SET is_read = 1 WHERE user_id = ? AND is_read = 0`,
userID)
return err
}
func (s *NotificationStore) Delete(ctx context.Context, id, userID string) error {
res, err := DB.ExecContext(ctx,
`DELETE FROM notifications WHERE id = ? AND user_id = ?`, id, userID)
if err != nil {
return err
}
n, _ := res.RowsAffected()
if n == 0 {
return sql.ErrNoRows
}
return nil
}
func (s *NotificationStore) UnreadCount(ctx context.Context, userID string) (int, error) {
var count int
err := DB.QueryRowContext(ctx,
`SELECT COUNT(*) FROM notifications WHERE user_id = ? AND is_read = 0`,
userID).Scan(&count)
return count, err
}
func (s *NotificationStore) DeleteOlderThan(ctx context.Context, before time.Time) (int64, error) {
res, err := DB.ExecContext(ctx,
`DELETE FROM notifications WHERE created_at < ?`,
before.UTC().Format(timeFmt))
if err != nil {
return 0, err
}
return res.RowsAffected()
}
// nullStr returns sql.NullString for optional string fields.
func nullStr(s string) sql.NullString {
if s == "" {
return sql.NullString{}
}
return sql.NullString{String: s, Valid: true}
}

70
server/store/sqlite/notification_prefs.go Normal file
View File

@@ -0,0 +1,70 @@
package sqlite
import (
"context"
"database/sql"
"git.gobha.me/xcaliber/chat-switchboard/models"
"git.gobha.me/xcaliber/chat-switchboard/store"
)
type NotificationPreferenceStore struct{}
func NewNotificationPreferenceStore() *NotificationPreferenceStore {
return &NotificationPreferenceStore{}
}
func (s *NotificationPreferenceStore) Get(ctx context.Context, userID, notifType string) (*models.NotificationPreference, error) {
var p models.NotificationPreference
err := DB.QueryRowContext(ctx, `
SELECT id, user_id, type, in_app, email
FROM notification_preferences
WHERE user_id = ? AND type = ?`, userID, notifType).Scan(
&p.ID, &p.UserID, &p.Type, &p.InApp, &p.Email)
if err == sql.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, err
}
return &p, nil
}
func (s *NotificationPreferenceStore) ListForUser(ctx context.Context, userID string) ([]models.NotificationPreference, error) {
rows, err := DB.QueryContext(ctx, `
SELECT id, user_id, type, in_app, email
FROM notification_preferences
WHERE user_id = ?
ORDER BY type`, userID)
if err != nil {
return nil, err
}
defer rows.Close()
var result []models.NotificationPreference
for rows.Next() {
var p models.NotificationPreference
if err := rows.Scan(&p.ID, &p.UserID, &p.Type, &p.InApp, &p.Email); err != nil {
return nil, err
}
result = append(result, p)
}
return result, rows.Err()
}
func (s *NotificationPreferenceStore) Upsert(ctx context.Context, pref *models.NotificationPreference) error {
_, err := DB.ExecContext(ctx, `
INSERT INTO notification_preferences (id, user_id, type, in_app, email)
VALUES (?, ?, ?, ?, ?)
ON CONFLICT (user_id, type) DO UPDATE SET
in_app = excluded.in_app, email = excluded.email`,
store.NewID(), pref.UserID, pref.Type, pref.InApp, pref.Email)
return err
}
func (s *NotificationPreferenceStore) Delete(ctx context.Context, userID, notifType string) error {
_, err := DB.ExecContext(ctx, `
DELETE FROM notification_preferences
WHERE user_id = ? AND type = ?`, userID, notifType)
return err
}

2
server/store/sqlite/stores.go
View File

@@ -33,5 +33,7 @@ func NewStores(db *sql.DB) store.Stores {
ResourceGrants: NewResourceGrantStore(),
Memories: NewMemoryStore(),
Projects: NewProjectStore(),
Notifications: NewNotificationStore(),
NotifPrefs: NewNotificationPreferenceStore(),
}
}

6
server/store/sqlite/user_settings.go
View File

@@ -15,8 +15,8 @@ func NewUserModelSettingsStore() *UserModelSettingsStore { return &UserModelSett
func (s *UserModelSettingsStore) GetForUser(ctx context.Context, userID string) ([]models.UserModelSetting, error) {
rows, err := DB.QueryContext(ctx, `
SELECT id, user_id, model_id, hidden, preferred_temperature, preferred_max_tokens,
sort_order, created_at, updated_at
SELECT id, user_id, model_id, COALESCE(hidden, 0), preferred_temperature, preferred_max_tokens,
COALESCE(sort_order, 0), created_at, updated_at
FROM user_model_settings WHERE user_id = ? ORDER BY sort_order, model_id`, userID)
if err != nil {
return nil, err
@@ -92,7 +92,7 @@ func (s *UserModelSettingsStore) Set(ctx context.Context, userID, modelID string
// Build a custom upsert since the update builder doesn't handle INSERT ON CONFLICT
_, err := DB.ExecContext(ctx, `
INSERT INTO user_model_settings (id, user_id, model_id, hidden, preferred_temperature, preferred_max_tokens, sort_order)
VALUES (?, ?, ?, ?, ?, ?, ?)
VALUES (?, ?, ?, COALESCE(?, 0), ?, ?, COALESCE(?, 0))
ON CONFLICT (user_id, model_id)
DO UPDATE SET
hidden = COALESCE(excluded.hidden, user_model_settings.hidden),

210
src/css/channel-models.css Normal file
View File

@@ -0,0 +1,210 @@
/* ==========================================
Channel Models — v0.20.0 Phase 2
Model pills, @mention autocomplete, add dialog
========================================== */
/* ── Model Pills (chat header) ───────────── */
.ch-model-pills {
display: none; /* shown by JS when roster > 1 */
align-items: center;
gap: 4px;
padding: 0 8px;
flex-shrink: 1;
overflow-x: auto;
scrollbar-width: none;
}
.ch-model-pills::-webkit-scrollbar { display: none; }
.ch-model-pill {
display: inline-flex;
align-items: center;
gap: 2px;
padding: 2px 8px;
border-radius: 12px;
background: var(--bg-secondary, #f0f0f0);
border: 1px solid var(--border-color, #ddd);
font-size: 0.75rem;
white-space: nowrap;
cursor: default;
transition: background 0.15s;
}
.ch-model-pill.ch-model-default {
background: var(--accent-bg, #e8f0fe);
border-color: var(--accent-color, #4a8af4);
}
.ch-model-pill-name {
cursor: pointer;
user-select: none;
}
.ch-model-pill-name:hover {
text-decoration: underline;
}
.ch-model-pill-remove {
background: none;
border: none;
cursor: pointer;
font-size: 0.65rem;
color: var(--text-secondary, #888);
padding: 0 2px;
line-height: 1;
opacity: 0.6;
transition: opacity 0.15s;
}
.ch-model-pill-remove:hover {
opacity: 1;
color: var(--error-color, #d32f2f);
}
.ch-model-add-btn {
background: none;
border: 1px dashed var(--border-color, #ccc);
border-radius: 12px;
padding: 2px 8px;
font-size: 0.75rem;
cursor: pointer;
color: var(--text-secondary, #888);
white-space: nowrap;
transition: color 0.15s, border-color 0.15s;
}
.ch-model-add-btn:hover {
color: var(--text-primary, #333);
border-color: var(--text-primary, #333);
}
/* ── Add Model Dialog ────────────────────── */
.ch-model-add-dialog {
position: fixed;
inset: 0;
display: flex;
align-items: center;
justify-content: center;
background: rgba(0,0,0,0.4);
z-index: 1100;
}
.ch-model-add-inner {
background: var(--bg-primary, #fff);
border-radius: 12px;
padding: 24px;
min-width: 320px;
max-width: 420px;
box-shadow: 0 8px 32px rgba(0,0,0,0.2);
}
.ch-model-add-inner h3 {
margin: 0 0 16px;
font-size: 1rem;
}
.ch-model-add-inner label {
display: block;
margin-bottom: 12px;
font-size: 0.85rem;
color: var(--text-secondary, #666);
}
.ch-model-add-inner select,
.ch-model-add-inner input[type="text"] {
display: block;
width: 100%;
margin-top: 4px;
padding: 8px;
border: 1px solid var(--border-color, #ddd);
border-radius: 6px;
font-size: 0.9rem;
background: var(--bg-primary, #fff);
color: var(--text-primary, #333);
box-sizing: border-box;
}
.ch-model-add-actions {
display: flex;
gap: 8px;
justify-content: flex-end;
margin-top: 16px;
}
/* ── @mention Autocomplete ───────────────── */
.mention-ac {
position: fixed;
z-index: 1050;
background: var(--bg-primary, #fff);
border: 1px solid var(--border-color, #ddd);
border-radius: 8px;
box-shadow: 0 4px 16px rgba(0,0,0,0.15);
max-height: 200px;
overflow-y: auto;
padding: 4px 0;
}
.mention-ac-item {
display: flex;
align-items: center;
justify-content: space-between;
padding: 8px 12px;
cursor: pointer;
gap: 12px;
transition: background 0.1s;
}
.mention-ac-item:hover,
.mention-ac-item.mention-ac-active {
background: var(--bg-secondary, #f5f5f5);
}
.mention-ac-name {
font-weight: 500;
font-size: 0.85rem;
}
.mention-ac-model {
font-size: 0.75rem;
color: var(--text-secondary, #999);
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
max-width: 160px;
}
/* ── Model Attribution (multi-model messages) ─ */
.msg-model-label {
display: inline-block;
font-size: 0.7rem;
font-weight: 600;
padding: 1px 6px;
border-radius: 4px;
background: var(--bg-secondary, #f0f0f0);
color: var(--text-secondary, #666);
margin-left: 6px;
vertical-align: middle;
}
/* Model separator in multi-model stream */
.model-stream-divider {
display: flex;
align-items: center;
gap: 8px;
padding: 12px 0 4px;
font-size: 0.8rem;
color: var(--text-secondary, #888);
font-weight: 500;
}
.model-stream-divider::before,
.model-stream-divider::after {
content: '';
flex: 1;
height: 1px;
background: var(--border-color, #eee);
}
/* ── Mobile ──────────────────────────────── */
@media (max-width: 768px) {
.ch-model-pills {
max-width: 50vw;
}
.ch-model-add-inner {
min-width: auto;
margin: 0 16px;
}
.mention-ac {
left: 8px !important;
right: 8px;
min-width: auto !important;
}
}

64
src/css/notification-prefs.css Normal file
View File

@@ -0,0 +1,64 @@
/* ==========================================
Notification Preferences — v0.20.0 Phase 3
========================================== */
.notif-pref-table {
width: 100%;
border-collapse: collapse;
font-size: 0.9rem;
}
.notif-pref-table th {
text-align: left;
padding: 6px 8px;
border-bottom: 2px solid var(--border-color, #ddd);
font-size: 0.8rem;
color: var(--text-secondary, #888);
font-weight: 500;
}
.notif-pref-table th:nth-child(2),
.notif-pref-table th:nth-child(3) {
text-align: center;
width: 70px;
}
.notif-pref-table td {
padding: 8px;
border-bottom: 1px solid var(--border-color, #eee);
}
.notif-pref-toggle {
text-align: center;
}
.notif-pref-label {
font-size: 0.85rem;
}
/* ── SMTP Config (Admin panel) ────────────── */
.smtp-config-grid {
display: grid;
grid-template-columns: 1fr 1fr;
gap: 12px;
}
.smtp-config-grid .form-group {
margin-bottom: 0;
}
.smtp-config-grid .form-group.full-width {
grid-column: 1 / -1;
}
.smtp-test-row {
display: flex;
align-items: center;
gap: 12px;
margin-top: 12px;
}
.smtp-test-status {
font-size: 0.85rem;
color: var(--text-secondary, #888);
}
.smtp-test-status.success { color: var(--success-color, #2e7d32); }
.smtp-test-status.error { color: var(--error-color, #d32f2f); }
@media (max-width: 600px) {
.smtp-config-grid {
grid-template-columns: 1fr;
}
}

249
src/css/notifications.css Normal file
View File

@@ -0,0 +1,249 @@
/* ==========================================
Notifications (v0.20.0)
========================================== */
/* ── Bell + Badge ──────────────────────────── */
.notif-wrap {
position: relative;
display: flex;
align-items: center;
margin-left: auto;
margin-right: 8px;
}
.notif-bell {
background: none;
border: none;
cursor: pointer;
padding: 4px 6px;
border-radius: 6px;
color: var(--text-secondary, #888);
display: flex;
align-items: center;
position: relative;
transition: background 0.15s;
}
.notif-bell:hover {
background: var(--hover-bg, rgba(128, 128, 128, 0.1));
color: var(--text-primary, #ddd);
}
.notif-badge {
position: absolute;
top: 0;
right: 0;
min-width: 16px;
height: 16px;
line-height: 16px;
font-size: 10px;
font-weight: 700;
text-align: center;
border-radius: 8px;
background: var(--accent-red, #e55);
color: #fff;
padding: 0 4px;
pointer-events: none;
}
/* ── Dropdown ──────────────────────────────── */
.notif-dropdown {
display: none;
position: absolute;
top: 100%;
right: 0;
width: 360px;
max-height: 480px;
background: var(--bg-surface, #1e1e1e);
border: 1px solid var(--border-color, #333);
border-radius: 8px;
box-shadow: 0 8px 24px rgba(0, 0, 0, 0.3);
z-index: 1000;
overflow: hidden;
}
.notif-dd-header {
display: flex;
justify-content: space-between;
align-items: center;
padding: 10px 14px;
border-bottom: 1px solid var(--border-color, #333);
font-weight: 600;
font-size: 13px;
}
.notif-mark-all {
background: none;
border: none;
color: var(--accent, #5b9);
cursor: pointer;
font-size: 12px;
padding: 2px 6px;
border-radius: 4px;
}
.notif-mark-all:hover {
background: var(--hover-bg, rgba(128, 128, 128, 0.1));
}
.notif-dd-list {
overflow-y: auto;
max-height: 380px;
}
.notif-dd-footer {
padding: 8px 14px;
border-top: 1px solid var(--border-color, #333);
text-align: center;
}
.notif-view-all {
background: none;
border: none;
color: var(--accent, #5b9);
cursor: pointer;
font-size: 12px;
}
.notif-view-all:hover {
text-decoration: underline;
}
/* ── Notification Item ─────────────────────── */
.notif-item,
.notif-panel-item {
display: flex;
align-items: flex-start;
padding: 10px 14px;
cursor: pointer;
transition: background 0.15s;
border-bottom: 1px solid var(--border-color, #222);
}
.notif-item:hover,
.notif-panel-item:hover {
background: var(--hover-bg, rgba(128, 128, 128, 0.08));
}
.notif-item.notif-unread,
.notif-panel-item.notif-unread {
background: var(--notif-unread-bg, rgba(91, 187, 153, 0.06));
}
.notif-dot {
flex-shrink: 0;
width: 18px;
font-size: 10px;
margin-top: 3px;
color: var(--accent, #5b9);
}
.notif-item:not(.notif-unread) .notif-dot,
.notif-panel-item:not(.notif-unread) .notif-dot {
color: var(--text-tertiary, #555);
}
.notif-body {
flex: 1;
min-width: 0;
}
.notif-title {
font-size: 13px;
line-height: 1.4;
color: var(--text-primary, #ddd);
}
.notif-detail {
font-size: 12px;
color: var(--text-secondary, #888);
margin-top: 2px;
line-height: 1.3;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.notif-time {
font-size: 11px;
color: var(--text-tertiary, #666);
margin-top: 3px;
}
.notif-empty {
padding: 32px 14px;
text-align: center;
color: var(--text-secondary, #888);
font-size: 13px;
}
/* ── Panel ─────────────────────────────────── */
.notif-panel {
height: 100%;
display: flex;
flex-direction: column;
}
.notif-panel-toolbar {
display: flex;
gap: 6px;
padding: 8px 12px;
border-bottom: 1px solid var(--border-color, #333);
}
.notif-panel-list {
flex: 1;
overflow-y: auto;
min-height: 0;
}
.notif-panel-row {
display: flex;
align-items: flex-start;
width: 100%;
}
.notif-delete {
flex-shrink: 0;
background: none;
border: none;
color: var(--text-tertiary, #555);
cursor: pointer;
padding: 2px 6px;
font-size: 12px;
border-radius: 4px;
opacity: 0;
transition: opacity 0.15s;
}
.notif-panel-item:hover .notif-delete {
opacity: 1;
}
.notif-delete:hover {
color: var(--accent-red, #e55);
background: var(--hover-bg, rgba(128, 128, 128, 0.1));
}
.notif-panel-more {
padding: 8px 12px;
text-align: center;
border-top: 1px solid var(--border-color, #333);
}
/* ── Mobile ────────────────────────────────── */
@media (max-width: 768px) {
.notif-dropdown {
position: fixed;
top: 48px;
left: 8px;
right: 8px;
width: auto;
max-height: calc(100vh - 96px);
}
}

47
src/index.html
View File

@@ -21,6 +21,9 @@
<link rel="stylesheet" href="css/styles.css?v=%%APP_VERSION%%">
<link rel="stylesheet" href="css/persona-kb.css?v=%%APP_VERSION%%">
<link rel="stylesheet" href="css/memory.css?v=%%APP_VERSION%%">
<link rel="stylesheet" href="css/notifications.css?v=%%APP_VERSION%%">
<link rel="stylesheet" href="css/channel-models.css?v=%%APP_VERSION%%">
<link rel="stylesheet" href="css/notification-prefs.css?v=%%APP_VERSION%%">
<link rel="stylesheet" href="branding/custom.css" onerror="this.remove()">
</head>
<body>
@@ -136,7 +139,15 @@
<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="23 4 23 10 17 10"/><path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"/></svg>
</button>
<div class="model-caps" id="modelCaps"></div>
<div class="ch-model-pills" id="channelModelPills"></div>
<span class="chat-token-count" id="chatTokenCount"></span>
<div class="notif-wrap" id="notifWrap">
<button class="notif-bell" id="notifBell" onclick="Notifications.toggleDropdown()" title="Notifications">
<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 8A6 6 0 0 0 6 8c0 7-3 9-3 9h18s-3-2-3-9"/><path d="M13.73 21a2 2 0 0 1-3.46 0"/></svg>
<span class="notif-badge" id="notifBadge" style="display:none">0</span>
</button>
<div class="notif-dropdown" id="notifDropdown"></div>
</div>
</div>
<div class="messages" id="chatMessages">
@@ -394,6 +405,7 @@
<button class="settings-tab" data-stab="roles" onclick="UI.switchSettingsTab('roles')" id="settingsRolesTabBtn">Model Roles</button>
<button class="settings-tab" data-stab="knowledgeBases" onclick="UI.switchSettingsTab('knowledgeBases')" id="settingsKBTabBtn" style="display:none">Knowledge</button>
<button class="settings-tab" data-stab="memory" onclick="UI.switchSettingsTab('memory')" id="settingsMemoryTabBtn">Memory</button>
<button class="settings-tab" data-stab="notifPrefs" onclick="UI.switchSettingsTab('notifPrefs')">Notifications</button>
</div>
<div class="modal-body">
<!-- General Tab -->
@@ -565,6 +577,14 @@
<div id="settingsMemoryContent"></div>
</section>
</div>
<!-- Notification Preferences Tab (v0.20.0 Phase 3) -->
<div class="settings-tab-content" id="settingsNotifPrefsTab" style="display:none">
<section class="settings-section">
<h3>Delivery Preferences</h3>
<p class="section-hint" style="margin-bottom:8px">Choose how you receive notifications. Email delivery requires admin SMTP configuration.</p>
<div id="notifPrefsBody"></div>
</section>
</div>
</div>
<div class="modal-footer"><button class="btn-primary" id="settingsSaveBtn">Save Settings</button></div>
</div>
@@ -935,6 +955,30 @@
<h4>🔐 Encryption</h4>
<div id="adminVaultStatus"><span class="empty-hint">Loading…</span></div>
</section>
<section class="settings-section">
<h3>Email Notifications (SMTP)</h3>
<label class="checkbox-label"><input type="checkbox" id="adminEmailEnabled"> Enable email notifications</label>
<div id="smtpConfigFields" style="display:none">
<div class="smtp-config-grid" style="margin-top:12px">
<div class="form-group"><label>SMTP Host</label><input type="text" id="adminSmtpHost" placeholder="smtp.example.com"></div>
<div class="form-group"><label>Port</label><input type="number" id="adminSmtpPort" value="587" min="1" max="65535" style="width:100px"></div>
<div class="form-group"><label>Username</label><input type="text" id="adminSmtpUser" placeholder="user@example.com"></div>
<div class="form-group"><label>Password</label><input type="password" id="adminSmtpPassword" placeholder="••••••••"></div>
<div class="form-group"><label>From Address</label><input type="text" id="adminSmtpFrom" placeholder="noreply@chat.example.com"></div>
<div class="form-group"><label>TLS Mode</label>
<select id="adminSmtpTls">
<option value="false">STARTTLS (port 587)</option>
<option value="true">Implicit TLS (port 465)</option>
</select>
</div>
</div>
<div class="smtp-test-row">
<button class="btn-small" id="adminSmtpTestBtn" onclick="NotifPrefs._testEmail()">Send Test Email</button>
<span class="smtp-test-status" id="smtpTestStatus"></span>
</div>
<p class="section-hint" style="margin-top:8px">Test sends to your account's email address. Save settings first, then test.</p>
</div>
</section>
<button class="btn-primary btn-small" id="adminSaveSettings">Save Settings</button>
</div>
<div class="admin-section-content" id="adminStorageTab" style="display:none"><div id="adminStorageContent"></div></div>
@@ -1131,6 +1175,9 @@
<script src="js/memory-ui.js?v=%%APP_VERSION%%"></script>
<script src="js/persona-kb.js?v=%%APP_VERSION%%"></script>
<script src="js/projects-ui.js?v=%%APP_VERSION%%"></script>
<script src="js/channel-models.js?v=%%APP_VERSION%%"></script>
<script src="js/notification-prefs.js?v=%%APP_VERSION%%"></script>
<script src="js/notifications.js?v=%%APP_VERSION%%"></script>
<script src="js/chat.js?v=%%APP_VERSION%%"></script>
<script src="js/settings-handlers.js?v=%%APP_VERSION%%"></script>
<script src="js/admin-handlers.js?v=%%APP_VERSION%%"></script>

13
src/js/api.js
View File

@@ -161,6 +161,18 @@ const API = {
generateTitle(id) { return this._post(`/api/v1/channels/${id}/generate-title`, {}); },
deleteChannel(id) { return this._del(`/api/v1/channels/${id}`); },
// Channel models (v0.20.0 — multi-model @mention routing)
listChannelModels(channelId) { return this._get(`/api/v1/channels/${channelId}/models`); },
addChannelModel(channelId, data) { return this._post(`/api/v1/channels/${channelId}/models`, data); },
updateChannelModel(channelId, modelId, data) { return this._patch(`/api/v1/channels/${channelId}/models/${modelId}`, data); },
deleteChannelModel(channelId, modelId) { return this._del(`/api/v1/channels/${channelId}/models/${modelId}`); },
// Notification preferences (v0.20.0 Phase 3)
listNotifPrefs() { return this._get('/api/v1/notifications/preferences'); },
setNotifPref(type, data) { return this._put(`/api/v1/notifications/preferences/${encodeURIComponent(type)}`, data); },
deleteNotifPref(type) { return this._del(`/api/v1/notifications/preferences/${encodeURIComponent(type)}`); },
adminTestEmail() { return this._post('/api/v1/admin/notifications/test-email', {}); },
// Projects (v0.19.0)
listProjects(includeArchived) {
const q = includeArchived ? '?include_archived=true' : '';
@@ -748,6 +760,7 @@ const API = {
async _post(path, body, skipAuth) { return skipAuth ? this._raw(path, 'POST', body) : this._authed(path, 'POST', body); },
async _put(path, body) { return this._authed(path, 'PUT', body); },
async _del(path) { return this._authed(path, 'DELETE'); },
async _patch(path, body) { return this._authed(path, 'PATCH', body); },
async _authed(path, method = 'GET', body) {
try {

1
src/js/app.js
View File

@@ -431,6 +431,7 @@ function initListeners() {
_registerPreviewPanel(); // from ui-format.js — register preview with PanelRegistry
_registerNotesPanel(); // from notes.js — register notes with PanelRegistry
_registerProjectPanel(); // from projects-ui.js — register project detail panel
if (typeof Notifications !== 'undefined') Notifications.init(); // v0.20.0
_initGlobalKeyboard(); // local: Escape, Ctrl+K, Ctrl+\, resize
_initSidePanelResize(); // from panels.js
_initDualDivider(); // from panels.js — dual-view split drag

340
src/js/channel-models.js Normal file
View File

@@ -0,0 +1,340 @@
// ==========================================
// Chat Switchboard – Channel Models (v0.20.0)
// ==========================================
// Multi-model management per channel.
// - Model pills in chat header (add/remove/set default)
// - @mention autocomplete in chat input
// - Model attribution on assistant messages
// ==========================================
const ChannelModels = {
_roster: [], // current channel's model roster
_channelId: null, // current channel ID
_acVisible: false, // autocomplete dropdown visible
// ── Init / Lifecycle ────────────────────
init() {
// Close autocomplete on click-outside
document.addEventListener('click', (e) => {
if (!e.target.closest('.mention-ac')) {
this.hideAutocomplete();
}
});
},
// ── Roster Management ───────────────────
async load(channelId) {
this._channelId = channelId;
if (!channelId) {
this._roster = [];
this.renderPills();
return;
}
try {
const roster = await API.listChannelModels(channelId);
this._roster = Array.isArray(roster) ? roster : [];
} catch (e) {
console.debug('Channel models not loaded:', e.message);
this._roster = [];
}
this.renderPills();
},
getRoster() { return this._roster; },
getDefault() {
return this._roster.find(m => m.is_default) || this._roster[0] || null;
},
// ── Model Pills UI ──────────────────────
renderPills() {
const container = document.getElementById('channelModelPills');
if (!container) return;
if (this._roster.length <= 1) {
container.style.display = 'none';
container.innerHTML = '';
return;
}
container.style.display = '';
const html = this._roster.map(m => `
<span class="ch-model-pill${m.is_default ? ' ch-model-default' : ''}"
data-model-id="${esc(m.id)}" title="${esc(m.model_id)}">
<span class="ch-model-pill-name" onclick="ChannelModels.setDefault('${esc(m.id)}')">${esc(m.display_name)}</span>
<button class="ch-model-pill-remove" onclick="ChannelModels.remove('${esc(m.id)}')" title="Remove model">✕</button>
</span>
`).join('') + `
<button class="ch-model-add-btn" onclick="ChannelModels.showAddDialog()" title="Add model to channel">+ Add</button>
`;
container.innerHTML = html;
},
async remove(recordId) {
if (!this._channelId) return;
try {
const resp = await API.deleteChannelModel(this._channelId, recordId);
this._roster = resp.models || [];
this.renderPills();
} catch (e) {
UI.toast('Failed to remove model: ' + e.message, 'error');
}
},
async setDefault(recordId) {
if (!this._channelId) return;
try {
const resp = await API.updateChannelModel(this._channelId, recordId, { is_default: true });
this._roster = resp.models || [];
this.renderPills();
} catch (e) {
UI.toast('Failed to set default: ' + e.message, 'error');
}
},
// ── Add Model Dialog ────────────────────
showAddDialog() {
if (!App.models || App.models.length === 0) {
UI.toast('No models available — configure a provider first', 'warning');
return;
}
// Filter out models already in the roster
const rosterModelIds = new Set(this._roster.map(m => m.model_id));
const available = App.models.filter(m => !m.isPreset && !m.hidden && !rosterModelIds.has(m.baseModelId || m.id));
if (available.length === 0) {
UI.toast('All available models are already added to this channel', 'info');
return;
}
const html = `
<div class="ch-model-add-dialog" id="chModelAddDialog">
<div class="ch-model-add-inner">
<h3>Add Model to Channel</h3>
<label>Model
<select id="chModelAddSelect">
${available.map(m => `<option value="${esc(m.baseModelId || m.id)}" data-config="${esc(m.configId || '')}" data-name="${esc(m.name)}">${esc(m.name)}${m.provider ? ` (${esc(m.provider)})` : ''}</option>`).join('')}
</select>
</label>
<label>Display Name (used for @mentions)
<input type="text" id="chModelAddName" placeholder="e.g. Claude-3-Opus" maxlength="50">
</label>
<div class="ch-model-add-actions">
<button class="btn-secondary" onclick="ChannelModels.closeAddDialog()">Cancel</button>
<button class="btn-primary" onclick="ChannelModels.submitAdd()">Add</button>
</div>
</div>
</div>`;
document.body.insertAdjacentHTML('beforeend', html);
// Auto-fill display name from selected model
const select = document.getElementById('chModelAddSelect');
const nameInput = document.getElementById('chModelAddName');
nameInput.value = _shortName(select.options[0]?.dataset.name || '');
select.addEventListener('change', () => {
nameInput.value = _shortName(select.options[select.selectedIndex]?.dataset.name || '');
});
// Focus and select
nameInput.focus();
nameInput.select();
},
closeAddDialog() {
document.getElementById('chModelAddDialog')?.remove();
},
async submitAdd() {
const select = document.getElementById('chModelAddSelect');
const nameInput = document.getElementById('chModelAddName');
if (!select || !nameInput) return;
const modelId = select.value;
const configId = select.options[select.selectedIndex]?.dataset.config || '';
const displayName = nameInput.value.trim();
if (!displayName) {
UI.toast('Display name is required', 'warning');
return;
}
try {
const resp = await API.addChannelModel(this._channelId, {
model_id: modelId,
provider_config_id: configId,
display_name: displayName,
is_default: this._roster.length === 0
});
this._roster = resp.models || [];
this.renderPills();
this.closeAddDialog();
} catch (e) {
UI.toast('Failed to add model: ' + e.message, 'error');
}
},
// ── @mention Autocomplete ───────────────
/**
* Called from the chat input's keyup/input handler.
* Shows a dropdown of channel models when user types @.
*/
onInput(inputEl) {
if (this._roster.length < 2) return; // no autocomplete for single-model channels
const text = typeof inputEl.getValue === 'function' ? inputEl.getValue() : inputEl.value;
const cursorPos = typeof inputEl.getCursorPos === 'function' ? inputEl.getCursorPos() : inputEl.selectionStart;
// Find the @token being typed (search backward from cursor)
const before = text.slice(0, cursorPos);
const atIdx = before.lastIndexOf('@');
if (atIdx < 0) { this.hideAutocomplete(); return; }
// @ must be at start or preceded by whitespace
if (atIdx > 0 && before[atIdx - 1] !== ' ' && before[atIdx - 1] !== '\n') {
this.hideAutocomplete();
return;
}
const partial = before.slice(atIdx + 1).toLowerCase();
const matches = this._roster.filter(m =>
m.display_name.toLowerCase().startsWith(partial) ||
m.display_name.toLowerCase().replace(/-/g, ' ').startsWith(partial.replace(/-/g, ' '))
);
if (matches.length === 0) { this.hideAutocomplete(); return; }
this.showAutocomplete(inputEl, atIdx, cursorPos, matches);
},
showAutocomplete(inputEl, atIdx, cursorPos, matches) {
this.hideAutocomplete();
const wrap = document.createElement('div');
wrap.className = 'mention-ac';
wrap.id = 'mentionAc';
// Position relative to input
const inputRect = (inputEl.el || inputEl).getBoundingClientRect();
wrap.style.bottom = (window.innerHeight - inputRect.top + 4) + 'px';
wrap.style.left = inputRect.left + 'px';
wrap.style.minWidth = '200px';
matches.forEach((m, i) => {
const item = document.createElement('div');
item.className = 'mention-ac-item' + (i === 0 ? ' mention-ac-active' : '');
item.dataset.name = m.display_name;
item.innerHTML = `<span class="mention-ac-name">${esc(m.display_name)}</span><span class="mention-ac-model">${esc(m.model_id)}</span>`;
item.addEventListener('click', () => {
this._insertMention(inputEl, atIdx, cursorPos, m.display_name);
});
wrap.appendChild(item);
});
document.body.appendChild(wrap);
this._acVisible = true;
},
hideAutocomplete() {
document.getElementById('mentionAc')?.remove();
this._acVisible = false;
},
isAutocompleteVisible() { return this._acVisible; },
/**
* Handle arrow keys and Enter when autocomplete is visible.
* Returns true if the event was consumed.
*/
handleKey(e) {
if (!this._acVisible) return false;
const ac = document.getElementById('mentionAc');
if (!ac) return false;
const items = ac.querySelectorAll('.mention-ac-item');
let activeIdx = Array.from(items).findIndex(el => el.classList.contains('mention-ac-active'));
if (e.key === 'ArrowDown') {
e.preventDefault();
items[activeIdx]?.classList.remove('mention-ac-active');
activeIdx = (activeIdx + 1) % items.length;
items[activeIdx]?.classList.add('mention-ac-active');
return true;
}
if (e.key === 'ArrowUp') {
e.preventDefault();
items[activeIdx]?.classList.remove('mention-ac-active');
activeIdx = (activeIdx - 1 + items.length) % items.length;
items[activeIdx]?.classList.add('mention-ac-active');
return true;
}
if (e.key === 'Enter' || e.key === 'Tab') {
e.preventDefault();
const active = items[activeIdx];
if (active) {
active.click();
}
return true;
}
if (e.key === 'Escape') {
this.hideAutocomplete();
return true;
}
return false;
},
_insertMention(inputEl, atIdx, cursorPos, displayName) {
const text = typeof inputEl.getValue === 'function' ? inputEl.getValue() : inputEl.value;
const before = text.slice(0, atIdx);
const after = text.slice(cursorPos);
const newText = before + '@' + displayName + ' ' + after;
if (typeof inputEl.setValue === 'function') {
inputEl.setValue(newText);
} else {
inputEl.value = newText;
}
// Position cursor after the inserted mention
const newPos = atIdx + 1 + displayName.length + 1;
if (typeof inputEl.setCursorPos === 'function') {
inputEl.setCursorPos(newPos);
} else {
inputEl.selectionStart = inputEl.selectionEnd = newPos;
}
this.hideAutocomplete();
inputEl.focus?.();
},
// ── Model Display Name Resolution ───────
/**
* Resolve a model_id to a display name using the current roster.
* Falls back to App.models lookup, then the raw model_id.
*/
resolveDisplayName(modelId) {
if (!modelId) return 'Assistant';
const cm = this._roster.find(m => m.model_id === modelId);
if (cm?.display_name) return cm.display_name;
const m = App.models?.find(x => x.id === modelId || x.baseModelId === modelId);
return m?.name || modelId;
}
};
// ── Helpers ──────────────────────────────────
function _shortName(fullName) {
// "Claude 3 Opus (Anthropic)" → "Claude-3-Opus"
return fullName
.replace(/\s*\([^)]*\)\s*$/, '') // strip "(provider)"
.trim()
.replace(/\s+/g, '-'); // spaces → hyphens
}

48
src/js/chat.js
View File

@@ -37,12 +37,37 @@ const ChatInput = {
return this._textarea;
},
/** Get the visible input element (for positioning, getBoundingClientRect) */
get el() {
if (this._editor) return this._editor.getView().dom;
return this._textarea;
},
/** Get the wrapper DOM element (for resize, etc.) */
getWrapDom() {
if (this._editor) return this._editor.getView().dom;
return this._textarea;
},
/** Get cursor byte offset (for @mention autocomplete) */
getCursorPos() {
if (this._editor) {
const view = this._editor.getView();
return view.state.selection.main.head;
}
return this._textarea?.selectionStart || 0;
},
/** Set cursor byte offset (for @mention autocomplete) */
setCursorPos(pos) {
if (this._editor) {
const view = this._editor.getView();
view.dispatch({ selection: { anchor: pos } });
} else if (this._textarea) {
this._textarea.selectionStart = this._textarea.selectionEnd = pos;
}
},
/** Initialize — try CM6, fall back to textarea */
init() {
this._textarea = document.getElementById('messageInput');
@@ -54,20 +79,35 @@ const ChatInput = {
this._editor = CM.chatInput(wrap, {
placeholder: 'Send a message...',
onSubmit: () => sendMessage(),
onChange: () => updateInputTokens(),
onChange: () => {
updateInputTokens();
// @mention autocomplete (v0.20.0)
if (typeof ChannelModels !== 'undefined') ChannelModels.onInput(ChatInput);
},
maxHeight: 200,
});
// @mention autocomplete: intercept keys on CM6 contentDOM (v0.20.0)
this._editor.getView().contentDOM.addEventListener('keydown', (e) => {
if (typeof ChannelModels !== 'undefined' && ChannelModels.handleKey(e)) {
e.preventDefault();
e.stopPropagation();
}
});
DebugLog?.push?.('chat', '[CM6] Chat input initialized');
} else {
// Fallback: textarea with manual event handling
DebugLog?.push?.('chat', '[CM6] Not available — using textarea fallback');
this._textarea.addEventListener('keydown', (e) => {
// @mention autocomplete intercepts arrow/enter/escape (v0.20.0)
if (typeof ChannelModels !== 'undefined' && ChannelModels.handleKey(e)) return;
if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); sendMessage(); }
});
this._textarea.addEventListener('input', function() {
this.style.height = 'auto';
this.style.height = Math.min(this.scrollHeight, 200) + 'px';
updateInputTokens();
// @mention autocomplete (v0.20.0)
if (typeof ChannelModels !== 'undefined') ChannelModels.onInput(this);
});
}
},
@@ -202,6 +242,9 @@ async function selectChat(chatId) {
// Restore the last-used model/preset for this chat
_restoreChatModel(chatId, chat);
// Load multi-model roster for @mention routing (v0.20.0)
if (typeof ChannelModels !== 'undefined') ChannelModels.load(chatId);
// Load attachments for message rendering (non-blocking, best-effort)
await loadChannelAttachments(chatId);
@@ -827,6 +870,9 @@ function _initChatListeners() {
// Input — CM6 or textarea fallback
ChatInput.init();
// Multi-model channel roster (v0.20.0)
if (typeof ChannelModels !== 'undefined') ChannelModels.init();
// Close modals on overlay click
document.querySelectorAll('.modal-overlay').forEach(overlay => {
overlay.addEventListener('click', (e) => {

163
src/js/notification-prefs.js Normal file
View File

@@ -0,0 +1,163 @@
/* ─────────────────────────────────────────────
Notification Preferences (v0.20.0 Phase 3)
Settings → Notifications tab
───────────────────────────────────────────── */
// eslint-disable-next-line no-unused-vars
const NotifPrefs = {
_loaded: false,
_prefs: [],
// Known notification types for the UI
_types: [
{ key: 'kb.ready', label: 'Knowledge base ready' },
{ key: 'kb.error', label: 'Knowledge base error' },
{ key: 'role.fallback', label: 'Model fallback' },
{ key: 'grant.changed', label: 'Group membership change' },
{ key: '*', label: 'Default (all others)' },
],
async load() {
try {
this._prefs = await API.listNotifPrefs() || [];
} catch (e) {
console.warn('[notif-prefs] failed to load:', e.message);
this._prefs = [];
}
this._loaded = true;
this.render();
},
render() {
const container = document.getElementById('notifPrefsBody');
if (!container) return;
const prefMap = {};
for (const p of this._prefs) {
prefMap[p.type] = p;
}
let html = '';
for (const t of this._types) {
const p = prefMap[t.key];
const inApp = p ? p.in_app : true;
const email = p ? p.email : false;
html += `<tr class="notif-pref-row" data-type="${esc(t.key)}">
<td class="notif-pref-label">${esc(t.label)}</td>
<td class="notif-pref-toggle">
<label class="checkbox-label">
<input type="checkbox" class="notif-pref-inapp" ${inApp ? 'checked' : ''}>
</label>
</td>
<td class="notif-pref-toggle">
<label class="checkbox-label">
<input type="checkbox" class="notif-pref-email" ${email ? 'checked' : ''}>
</label>
</td>
</tr>`;
}
container.innerHTML = `<table class="notif-pref-table">
<thead><tr>
<th>Notification Type</th>
<th>In-App</th>
<th>Email</th>
</tr></thead>
<tbody>${html}</tbody>
</table>`;
// Attach change listeners
container.querySelectorAll('.notif-pref-row').forEach(row => {
const type = row.dataset.type;
row.querySelector('.notif-pref-inapp').addEventListener('change', (e) => {
this._save(type, { in_app: e.target.checked });
});
row.querySelector('.notif-pref-email').addEventListener('change', (e) => {
this._save(type, { email: e.target.checked });
});
});
},
async _save(type, patch) {
try {
await API.setNotifPref(type, patch);
// Update cache
const existing = this._prefs.find(p => p.type === type);
if (existing) {
Object.assign(existing, patch);
} else {
this._prefs.push({ type, in_app: true, email: false, ...patch });
}
} catch (e) {
UI.toast('Failed to save preference', 'error');
this.render(); // revert checkboxes
}
},
};
// ── Admin SMTP UI helpers ───────────────────
// Called from index.html onclick
// eslint-disable-next-line no-unused-vars
NotifPrefs._testEmail = async function() {
const status = document.getElementById('smtpTestStatus');
const btn = document.getElementById('adminSmtpTestBtn');
if (!status || !btn) return;
btn.disabled = true;
status.textContent = 'Sending…';
status.className = 'smtp-test-status';
try {
const result = await API.adminTestEmail();
status.textContent = `✓ Sent to ${result.sent_to}`;
status.className = 'smtp-test-status success';
} catch (e) {
status.textContent = '✗ ' + (e.message || 'Failed');
status.className = 'smtp-test-status error';
} finally {
btn.disabled = false;
}
};
NotifPrefs._initAdminSmtp = function() {
const toggle = document.getElementById('adminEmailEnabled');
const fields = document.getElementById('smtpConfigFields');
if (!toggle || !fields) return;
toggle.addEventListener('change', () => {
fields.style.display = toggle.checked ? '' : 'none';
});
};
NotifPrefs._loadAdminSmtp = function(cfg) {
if (!cfg) return;
const el = (id) => document.getElementById(id);
if (cfg.email_enabled) el('adminEmailEnabled').checked = true;
if (cfg.smtp_host) el('adminSmtpHost').value = cfg.smtp_host;
if (cfg.smtp_port) el('adminSmtpPort').value = cfg.smtp_port;
if (cfg.smtp_user) el('adminSmtpUser').value = cfg.smtp_user;
// Don't populate password (security)
if (cfg.smtp_from) el('adminSmtpFrom').value = cfg.smtp_from;
if (cfg.smtp_tls != null) el('adminSmtpTls').value = String(cfg.smtp_tls);
// Show/hide SMTP fields
const fields = document.getElementById('smtpConfigFields');
if (fields) fields.style.display = cfg.email_enabled ? '' : 'none';
};
NotifPrefs._getAdminSmtp = function() {
const el = (id) => document.getElementById(id);
const config = {
email_enabled: el('adminEmailEnabled')?.checked || false,
smtp_host: el('adminSmtpHost')?.value?.trim() || '',
smtp_port: parseInt(el('adminSmtpPort')?.value) || 587,
smtp_user: el('adminSmtpUser')?.value?.trim() || '',
smtp_from: el('adminSmtpFrom')?.value?.trim() || '',
smtp_tls: el('adminSmtpTls')?.value === 'true',
};
// Only include password if user typed something new
const pw = el('adminSmtpPassword')?.value;
if (pw) config.smtp_password = pw;
return config;
};

431
src/js/notifications.js Normal file
View File

@@ -0,0 +1,431 @@
// ==========================================
// Chat Switchboard – Notifications (v0.20.0)
// ==========================================
// In-app notification bell with dropdown and
// side panel. Real-time push via WebSocket.
//
// Dependencies: API, Events, PanelRegistry, UI
// ==========================================
const Notifications = {
_items: [], // cached notifications (latest first)
_unreadCount: 0,
_loaded: false, // full list fetched at least once
_dropdownOpen: false,
// ── Init ─────────────────────────────────
async init() {
this._bindEvents();
this._registerPanel();
await this._fetchUnreadCount();
},
// ── Data ─────────────────────────────────
async _fetchUnreadCount() {
try {
const data = await API._get('/notifications/unread-count');
this._unreadCount = data.count || 0;
this._renderBadge();
} catch (e) {
// Silently fail — badge just stays at 0
}
},
async _fetchList(opts = {}) {
const limit = opts.limit || 20;
const offset = opts.offset || 0;
const unreadOnly = opts.unreadOnly || false;
try {
const data = await API._get(
`/notifications?limit=${limit}&offset=${offset}&unread_only=${unreadOnly}`);
return data;
} catch (e) {
return { data: [], total: 0 };
}
},
async _loadLatest() {
const result = await this._fetchList({ limit: 10 });
this._items = result.data || [];
this._loaded = true;
return result;
},
// ── Badge ────────────────────────────────
_renderBadge() {
const badge = document.getElementById('notifBadge');
if (!badge) return;
if (this._unreadCount > 0) {
badge.textContent = this._unreadCount > 9 ? '9+' : String(this._unreadCount);
badge.style.display = '';
} else {
badge.style.display = 'none';
}
},
// ── Dropdown ─────────────────────────────
async toggleDropdown() {
if (this._dropdownOpen) {
this._closeDropdown();
return;
}
// Lazy-load on first open
if (!this._loaded) {
await this._loadLatest();
}
const dd = document.getElementById('notifDropdown');
if (!dd) return;
dd.innerHTML = this._renderDropdownContent();
dd.style.display = 'block';
this._dropdownOpen = true;
// Click-outside handler
setTimeout(() => {
document.addEventListener('click', this._outsideClickHandler);
}, 0);
},
_closeDropdown() {
const dd = document.getElementById('notifDropdown');
if (dd) dd.style.display = 'none';
this._dropdownOpen = false;
document.removeEventListener('click', this._outsideClickHandler);
},
_outsideClickHandler(e) {
const wrap = document.getElementById('notifWrap');
if (wrap && !wrap.contains(e.target)) {
Notifications._closeDropdown();
}
},
_renderDropdownContent() {
const items = this._items;
if (!items.length) {
return `<div class="notif-empty">No notifications</div>`;
}
let html = `<div class="notif-dd-header">
<span>Notifications</span>
<button class="notif-mark-all" onclick="Notifications.markAllRead()">Mark all ✓</button>
</div><div class="notif-dd-list">`;
for (const n of items.slice(0, 10)) {
const unread = !n.is_read;
const dot = unread ? '●' : '○';
const cls = unread ? 'notif-item notif-unread' : 'notif-item';
const ago = _timeAgo(n.created_at);
html += `<div class="${cls}" data-id="${n.id}" data-resource-type="${n.resource_type || ''}" data-resource-id="${n.resource_id || ''}" onclick="Notifications._onItemClick(this)">
<span class="notif-dot">${dot}</span>
<div class="notif-body">
<div class="notif-title">${_esc(n.title)}</div>
${n.body ? `<div class="notif-detail">${_esc(n.body)}</div>` : ''}
<div class="notif-time">${ago}</div>
</div>
</div>`;
}
html += `</div>`;
html += `<div class="notif-dd-footer">
<button class="notif-view-all" onclick="Notifications.openPanel()">View all →</button>
</div>`;
return html;
},
// ── Item Actions ─────────────────────────
async _onItemClick(el) {
const id = el.dataset.id;
const resType = el.dataset.resourceType;
const resId = el.dataset.resourceId;
// Mark read
if (el.classList.contains('notif-unread')) {
await this._markRead(id);
el.classList.remove('notif-unread');
el.querySelector('.notif-dot').textContent = '○';
}
// Navigate
this._navigate(resType, resId);
this._closeDropdown();
},
_navigate(resourceType, resourceId) {
if (!resourceType || !resourceId) return;
switch (resourceType) {
case 'channel':
if (typeof selectChat === 'function') selectChat(resourceId);
break;
case 'knowledge_base':
// Open admin panel → KB section (if admin)
if (API.isAdmin && typeof showAdmin === 'function') {
showAdmin('ai', 'knowledge-bases');
}
break;
case 'project':
// Open project detail panel
if (typeof openProjectPanel === 'function') openProjectPanel(resourceId);
break;
case 'group':
if (API.isAdmin && typeof showAdmin === 'function') {
showAdmin('people', 'groups');
}
break;
}
},
async _markRead(id) {
try {
await API._authed(`/notifications/${id}/read`, 'PATCH');
this._unreadCount = Math.max(0, this._unreadCount - 1);
const item = this._items.find(n => n.id === id);
if (item) item.is_read = true;
this._renderBadge();
} catch (e) { /* best effort */ }
},
async markAllRead() {
try {
await API._post('/notifications/mark-all-read');
this._unreadCount = 0;
this._items.forEach(n => n.is_read = true);
this._renderBadge();
// Re-render dropdown if open
if (this._dropdownOpen) {
const dd = document.getElementById('notifDropdown');
if (dd) dd.innerHTML = this._renderDropdownContent();
}
// Re-render panel if open
this._renderPanelContent();
} catch (e) { /* best effort */ }
},
// ── Side Panel ───────────────────────────
_registerPanel() {
const body = document.getElementById('sidePanelBody');
if (!body || typeof PanelRegistry === 'undefined') return;
const el = document.createElement('div');
el.className = 'side-panel-page';
el.id = 'sidePanelNotifications';
el.style.display = 'none';
el.innerHTML = `<div class="notif-panel" id="notifPanelInner">
<div class="notif-panel-toolbar">
<button class="btn-small" onclick="Notifications.markAllRead()">Mark all read</button>
<button class="btn-small btn-danger" onclick="Notifications.clearAll()">Clear all</button>
</div>
<div class="notif-panel-list" id="notifPanelList"></div>
<div class="notif-panel-more" id="notifPanelMore" style="display:none">
<button class="btn-small" onclick="Notifications.loadMore()">Load more</button>
</div>
</div>`;
body.appendChild(el);
PanelRegistry.register('notifications', {
element: el,
label: 'Notifications',
onOpen: () => this._onPanelOpen(),
saveState: () => ({ scrollTop: el.querySelector('.notif-panel-list')?.scrollTop || 0 }),
restoreState: (s) => {
const list = el.querySelector('.notif-panel-list');
if (list && s.scrollTop) list.scrollTop = s.scrollTop;
},
});
},
_panelOffset: 0,
_panelTotal: 0,
async _onPanelOpen() {
this._panelOffset = 0;
const result = await this._fetchList({ limit: 30 });
this._panelTotal = result.total || 0;
this._panelOffset = (result.data || []).length;
this._panelItems = result.data || [];
this._renderPanelContent();
},
_panelItems: [],
_renderPanelContent() {
const list = document.getElementById('notifPanelList');
if (!list) return;
if (!this._panelItems.length) {
list.innerHTML = '<div class="notif-empty">No notifications yet</div>';
return;
}
let html = '';
for (const n of this._panelItems) {
const unread = !n.is_read;
const cls = unread ? 'notif-panel-item notif-unread' : 'notif-panel-item';
const dot = unread ? '●' : '○';
const ago = _timeAgo(n.created_at);
html += `<div class="${cls}" data-id="${n.id}" data-resource-type="${n.resource_type || ''}" data-resource-id="${n.resource_id || ''}" onclick="Notifications._onPanelItemClick(this)">
<div class="notif-panel-row">
<span class="notif-dot">${dot}</span>
<div class="notif-body">
<div class="notif-title">${_esc(n.title)}</div>
${n.body ? `<div class="notif-detail">${_esc(n.body)}</div>` : ''}
<div class="notif-time">${ago}</div>
</div>
<button class="notif-delete" onclick="event.stopPropagation(); Notifications._deleteItem('${n.id}')" title="Delete">✕</button>
</div>
</div>`;
}
list.innerHTML = html;
// Show/hide load more
const moreBtn = document.getElementById('notifPanelMore');
if (moreBtn) {
moreBtn.style.display = this._panelOffset < this._panelTotal ? '' : 'none';
}
},
async _onPanelItemClick(el) {
const id = el.dataset.id;
const resType = el.dataset.resourceType;
const resId = el.dataset.resourceId;
if (el.classList.contains('notif-unread')) {
await this._markRead(id);
el.classList.remove('notif-unread');
el.querySelector('.notif-dot').textContent = '○';
const pItem = this._panelItems.find(n => n.id === id);
if (pItem) pItem.is_read = true;
}
this._navigate(resType, resId);
},
async _deleteItem(id) {
try {
await API._del(`/notifications/${id}`);
// Check if it was unread before removal
const item = this._panelItems.find(n => n.id === id);
if (item && !item.is_read) {
this._unreadCount = Math.max(0, this._unreadCount - 1);
this._renderBadge();
}
this._panelItems = this._panelItems.filter(n => n.id !== id);
this._items = this._items.filter(n => n.id !== id);
this._panelTotal = Math.max(0, this._panelTotal - 1);
this._renderPanelContent();
} catch (e) { /* best effort */ }
},
async loadMore() {
const result = await this._fetchList({ limit: 30, offset: this._panelOffset });
const newItems = result.data || [];
this._panelItems = this._panelItems.concat(newItems);
this._panelOffset += newItems.length;
this._renderPanelContent();
},
async clearAll() {
if (typeof showConfirm === 'function') {
const ok = await showConfirm('Delete all notifications?', 'This cannot be undone.');
if (!ok) return;
}
// Delete visible items (API doesn't have bulk delete, so mark all read and let retention handle it)
await this.markAllRead();
},
openPanel() {
this._closeDropdown();
if (typeof PanelRegistry !== 'undefined') {
PanelRegistry.open('notifications');
}
},
// ── WebSocket Events ─────────────────────
_bindEvents() {
if (typeof Events === 'undefined') return;
// New notification from server
Events.on('notification.new', (payload) => {
// Prepend to cached list
this._items.unshift(payload);
if (this._items.length > 50) this._items.length = 50;
this._unreadCount++;
this._renderBadge();
// Update dropdown if open
if (this._dropdownOpen) {
const dd = document.getElementById('notifDropdown');
if (dd) dd.innerHTML = this._renderDropdownContent();
}
// Update panel if it has items
if (this._panelItems.length) {
this._panelItems.unshift(payload);
this._panelTotal++;
this._panelOffset++;
this._renderPanelContent();
}
// Toast for high-priority types
const highPriority = ['kb.error', 'role.fallback'];
if (highPriority.includes(payload.type)) {
if (typeof UI !== 'undefined' && UI.toast) {
UI.toast(payload.title, 'warning');
}
}
});
// Badge sync across tabs (from markRead / markAllRead in another tab)
Events.on('notification.read', (payload) => {
if (payload.action === 'mark_all_read') {
this._unreadCount = 0;
this._items.forEach(n => n.is_read = true);
this._panelItems.forEach(n => n.is_read = true);
} else if (payload.id) {
this._unreadCount = Math.max(0, this._unreadCount - 1);
const item = this._items.find(n => n.id === payload.id);
if (item) item.is_read = true;
const pItem = this._panelItems.find(n => n.id === payload.id);
if (pItem) pItem.is_read = true;
}
this._renderBadge();
if (this._dropdownOpen) {
const dd = document.getElementById('notifDropdown');
if (dd) dd.innerHTML = this._renderDropdownContent();
}
this._renderPanelContent();
});
},
};
// ── Helpers ──────────────────────────────────
function _esc(s) {
if (!s) return '';
const el = document.createElement('span');
el.textContent = s;
return el.innerHTML;
}
function _timeAgo(isoStr) {
if (!isoStr) return '';
const d = new Date(isoStr);
const now = Date.now();
const sec = Math.floor((now - d.getTime()) / 1000);
if (sec < 60) return 'just now';
if (sec < 3600) return `${Math.floor(sec / 60)}m ago`;
if (sec < 86400) return `${Math.floor(sec / 3600)}h ago`;
if (sec < 604800) return `${Math.floor(sec / 86400)}d ago`;
return d.toLocaleDateString();
}

6
src/js/settings-handlers.js
View File

@@ -256,6 +256,12 @@ async function handleSaveAdminSettings() {
}});
await API.adminUpdateSetting('memory_extraction_enabled', { value: memExtractionEnabled });
// Email / SMTP config (v0.20.0 Phase 3)
if (typeof NotifPrefs !== 'undefined' && NotifPrefs._getAdminSmtp) {
const smtpConfig = NotifPrefs._getAdminSmtp();
await API.adminUpdateSetting('notifications', { value: smtpConfig });
}
UI.toast('Settings saved', 'success');
// Live-apply: refresh policies and dependent UI
await initBanners();

7
src/js/ui-admin.js
View File

@@ -981,6 +981,13 @@ Object.assign(UI, {
const memAutoApprove = document.getElementById('adminMemoryAutoApprove');
if (memAutoApprove) memAutoApprove.checked = !!memExtractionCfg.auto_approve;
// Email / SMTP config (v0.20.0 Phase 3)
const notifCfg = getSetting('notifications', {}) || {};
if (typeof NotifPrefs !== 'undefined') {
NotifPrefs._loadAdminSmtp(notifCfg);
NotifPrefs._initAdminSmtp();
}
if (vaultEl) {
try {
const vault = await API.adminGetVaultStatus();

121
src/js/ui-core.js
View File

@@ -598,24 +598,39 @@ const UI = {
const label = modelName || 'Assistant';
const currentModel = App.findModel(App.settings.model);
const streamAvatar = currentModel?.presetAvatar || null;
const div = document.createElement('div');
div.className = 'message assistant';
div.innerHTML = `
<div class="msg-inner">
<div class="msg-avatar">${avatarHTML('assistant', streamAvatar)}</div>
<div class="msg-body">
<div class="msg-head"><span class="msg-role">${esc(label)}</span></div>
<div class="msg-tools" id="streamTools" style="display:none"></div>
<div class="msg-text" id="streamContent"></div>
</div>
</div>`;
container.appendChild(div);
// Multi-model state: when model_start events arrive, we create
// separate message bubbles per model. Without them, single-bubble.
let multiModel = false;
let activeContentEl = null;
let activeToolsEl = null;
let content = '';
let reasoning = '';
// Create initial single-model bubble (replaced if multi-model)
const _createBubble = (bubbleLabel) => {
const div = document.createElement('div');
div.className = 'message assistant';
div.innerHTML = `
<div class="msg-inner">
<div class="msg-avatar">${avatarHTML('assistant', streamAvatar)}</div>
<div class="msg-body">
<div class="msg-head"><span class="msg-role">${esc(bubbleLabel)}</span></div>
<div class="msg-tools" style="display:none"></div>
<div class="msg-text"></div>
</div>
</div>`;
container.appendChild(div);
activeContentEl = div.querySelector('.msg-text');
activeToolsEl = div.querySelector('.msg-tools');
return div;
};
_createBubble(label);
const reader = response.body.getReader();
const decoder = new TextDecoder();
let buffer = '';
let content = '';
let reasoning = '';
let currentEvent = ''; // SSE event type
while (true) {
@@ -640,16 +655,34 @@ const UI = {
try {
const parsed = JSON.parse(data);
// ── Multi-model: model_start creates a new bubble ──
if (currentEvent === 'model_start') {
if (!multiModel) {
// First model_start: remove the initial empty bubble
multiModel = true;
container.lastElementChild?.remove();
}
content = '';
reasoning = '';
const dn = parsed.display_name || parsed.model_id || 'Model';
_createBubble(dn);
currentEvent = '';
continue;
}
if (currentEvent === 'model_end') {
currentEvent = '';
continue;
}
if (currentEvent === 'tool_use') {
// parsed = array of tool calls
this._renderToolUse(parsed);
this._renderToolUseInEl(activeToolsEl, parsed);
currentEvent = '';
continue;
}
if (currentEvent === 'tool_result') {
// parsed = { tool_call_id, name, content, is_error }
this._renderToolResult(parsed);
this._renderToolResultInEl(activeToolsEl, parsed);
currentEvent = '';
continue;
}
@@ -658,9 +691,8 @@ const UI = {
const reasoningDelta = parsed.choices?.[0]?.delta?.reasoning_content || '';
if (reasoningDelta) {
reasoning += reasoningDelta;
// Render accumulated reasoning + content together
const full = (reasoning ? '<think>' + reasoning + '</think>' : '') + content;
document.getElementById('streamContent').innerHTML = formatMessage(full);
if (activeContentEl) activeContentEl.innerHTML = formatMessage(full);
this._scrollToBottom();
}
@@ -669,7 +701,7 @@ const UI = {
if (delta) {
content += delta;
const full = (reasoning ? '<think>' + reasoning + '</think>' : '') + content;
document.getElementById('streamContent').innerHTML = formatMessage(full);
if (activeContentEl) activeContentEl.innerHTML = formatMessage(full);
this._scrollToBottom();
// Live-update preview panel if open (debounced)
@@ -685,6 +717,43 @@ const UI = {
return content;
},
// Tool rendering helpers that take explicit element refs (for multi-model)
_renderToolUseInEl(toolsEl, toolCalls) {
if (!toolsEl) {
// Fallback to id-based (single model compat)
this._renderToolUse(toolCalls);
return;
}
toolsEl.style.display = '';
for (const tc of toolCalls) {
const name = tc.function?.name || tc.name || 'unknown';
const toolDiv = document.createElement('div');
toolDiv.className = 'tool-activity';
toolDiv.dataset.toolId = tc.id;
toolDiv.innerHTML = `
<span class="tool-icon">🔧</span>
<span class="tool-name">${esc(name)}</span>
<span class="tool-status tool-running">running…</span>`;
toolsEl.appendChild(toolDiv);
}
this._scrollToBottom();
},
_renderToolResultInEl(toolsEl, result) {
if (!toolsEl) {
this._renderToolResult(result);
return;
}
const el = toolsEl.querySelector(`[data-tool-id="${result.tool_call_id}"]`);
if (el) {
const statusEl = el.querySelector('.tool-status');
if (statusEl) {
statusEl.textContent = result.is_error ? 'error' : 'done';
statusEl.className = `tool-status ${result.is_error ? 'tool-error' : 'tool-done'}`;
}
}
},
_renderToolUse(toolCalls) {
const el = document.getElementById('streamTools');
if (!el) return;
@@ -693,7 +762,7 @@ const UI = {
const name = tc.function?.name || tc.name || 'unknown';
const toolDiv = document.createElement('div');
toolDiv.className = 'tool-activity';
toolDiv.id = `tool_${tc.id}`;
toolDiv.dataset.toolId = tc.id;
toolDiv.innerHTML = `
<span class="tool-icon">🔧</span>
<span class="tool-name">${esc(name)}</span>
@@ -704,7 +773,8 @@ const UI = {
},
_renderToolResult(result) {
const el = document.getElementById(`tool_${result.tool_call_id}`);
// Search all tool-activity elements by data-tool-id
const el = document.querySelector(`[data-tool-id="${result.tool_call_id}"]`);
if (el) {
const statusEl = el.querySelector('.tool-status');
if (statusEl) {
@@ -1052,6 +1122,11 @@ const UI = {
if (c) c.innerHTML = '<div style="padding:20px;color:var(--text-3);text-align:center">Memory UI failed to load.</div>';
}
}
if (tab === 'notifPrefs') {
if (typeof NotifPrefs !== 'undefined') {
NotifPrefs.load();
}
}
},
// ── Export ────────────────────────────────