ompchamber 1.1.0 → 1.2.0

package/src/server/routes/btw/ws.ts

@@ -0,0 +1,136 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * WebSocket transport for a session's BTW frame stream — the default sibling
+ * of `GET /api/btw/:sessionId/events`, mirroring the agent stream's protocol:
+ * one duplex socket per session, bare JSON frames, `connected` first, a
+ * protocol-level ping/pong keepalive, and the same latest-wins coalescer.
+ *
+ * A client that attaches replays nothing: the socket's first `btw_state` is
+ * the session's current history, so a reload lands on the same panel a live
+ * stream would have produced.
+ */
+
+import { Elysia, t } from 'elysia';
+import { createEventCoalescer, type EventCoalescer } from '@/server/lib/sse';
+import { STREAM_HEARTBEAT_MS } from '@/shared/lib/workspace/refresh-cadence';
+import { btwStateFor, subscribeBtw } from '@/server/lib/btw/registry.server';
+import type { BtwFrame } from '@/shared/types';
+
+/** Coalesce frames once this many bytes sit unsent. */
+const HIGH_WATER_BYTES = 256 * 1024;
+
+/** Longest a coalesced frame may wait before it is flushed anyway. */
+const FLUSH_DELAY_MS = 50;
+
+interface ConnectionState {
+  closed: boolean;
+  unsubscribe: (() => void) | null;
+  heartbeat: ReturnType<typeof setInterval> | null;
+  awaitingPong: boolean;
+  coalescer: EventCoalescer | null;
+}
+
+const connections = new WeakMap<object, ConnectionState>();
+
+export const btwWsRoutes = new Elysia({ prefix: '/api/btw' }).ws('/:sessionId/ws', {
+  params: t.Object({ sessionId: t.String() }),
+
+  open(ws) {
+    const sessionId = ws.data.params.sessionId;
+    const state: ConnectionState = { closed: false, unsubscribe: null, heartbeat: null, awaitingPong: false, coalescer: null };
+    connections.set(ws, state);
+    // Unchecked: Elysia exposes the server socket untyped. Both members are
+    // optional, so an absent one degrades (no byte count / no keepalive)
+    // instead of failing.
+    const raw = ws.raw as { bufferedAmount?: number; ping?: () => void };
+
+    const teardown = () => {
+      if (state.closed) return;
+      state.closed = true;
+      state.coalescer?.dispose();
+      state.coalescer = null;
+      if (state.heartbeat !== null) {
+        clearInterval(state.heartbeat);
+        state.heartbeat = null;
+      }
+      if (state.unsubscribe) {
+        try {
+          state.unsubscribe();
+        } catch {
+          // Subscriber cleanup is best-effort.
+        }
+        state.unsubscribe = null;
+      }
+      try {
+        ws.close();
+      } catch {
+        // Already gone.
+      }
+    };
+
+    state.coalescer = createEventCoalescer({
+      send: (_event, data) => {
+        try {
+          ws.send(JSON.stringify(data));
+        } catch {
+          teardown();
+        }
+      },
+      isBackpressured: () => (raw.bufferedAmount ?? 0) > HIGH_WATER_BYTES,
+      flushDelayMs: FLUSH_DELAY_MS,
+    });
+
+    state.heartbeat = setInterval(() => {
+      if (state.closed) return;
+      if (state.awaitingPong) {
+        teardown();
+        return;
+      }
+      state.awaitingPong = true;
+      if (!state.coalescer?.flush()) return;
+      try {
+        raw.ping?.();
+      } catch {
+        teardown();
+      }
+    }, STREAM_HEARTBEAT_MS);
+
+    const push = (frame: BtwFrame) => state.coalescer?.push('', frame);
+    state.unsubscribe = subscribeBtw(sessionId, push);
+    push({ type: 'connected', sessionId });
+    void btwStateFor(sessionId)
+      .then((snapshot) => push({ type: 'btw_state', state: snapshot }))
+      .catch((error: unknown) => {
+        push({ type: 'btw_error', topicId: null, message: error instanceof Error ? error.message : String(error) });
+      });
+  },
+
+  pong(ws) {
+    const state = connections.get(ws);
+    if (state) state.awaitingPong = false;
+  },
+
+  message() {
+    // Observer-only: commands go through POST /api/btw/:sessionId.
+  },
+
+  close(ws) {
+    const state = connections.get(ws);
+    if (!state || state.closed) return;
+    state.closed = true;
+    state.coalescer?.dispose();
+    state.coalescer = null;
+    if (state.heartbeat !== null) clearInterval(state.heartbeat);
+    if (state.unsubscribe) {
+      try {
+        state.unsubscribe();
+      } catch {
+        // Subscriber cleanup is best-effort.
+      }
+    }
+  },
+});

package/src/server/routes/chat/index.ts

@@ -3,10 +3,12 @@ import * as chatRoot from '@/server/routes/chat/root';
 import * as chatSession from '@/server/routes/chat/session';
 import * as chatRewind from '@/server/routes/chat/rewind';
 import * as chatStream from '@/server/routes/chat/stream';
+import * as chatTurns from '@/server/routes/chat/turns';
 
 export const chatBindings: HandlerBinding[] = [
   ...bindingsFor(chatRoot, '/api/chat'),
   ...bindingsFor(chatSession, '/api/chat/:sessionId'),
   ...bindingsFor(chatRewind, '/api/chat/:sessionId/rewind'),
   ...bindingsFor(chatStream, '/api/chat/stream'),
+  ...bindingsFor(chatTurns, '/api/chat/:sessionId/turns'),
 ];

package/src/server/routes/chat/session.ts

@@ -6,6 +6,7 @@ import { getSessionData } from '@/client/data/mock/chat';
 import { isMockMode } from '@/server/mock.server';
 import { findSessionFileById } from '@/server/lib/omp/session/locator';
 import { loadSessionMessages, loadSessionModel, loadSessionThinkingLevel, loadSessionTitle } from '@/server/lib/omp/session/messages';
+import { mergeOmpAttachments } from '@/server/lib/omp/session/merge-stored';
 import { readRawHeaderLine } from '@/server/lib/omp/session/files';
 import { formatNewSessionTitle } from '@/shared/lib/omp/session/default-title';
 
@@ -15,121 +16,6 @@ import { formatNewSessionTitle } from '@/shared/lib/omp/session/default-title';
  *  payload (and the mobile parse+mount cost) bounded. */
 const DEFAULT_MESSAGE_WINDOW = 120;
 
-interface StoredAttachment {
-  name?: string;
-  preview?: string;
-  type?: string;
-  size?: number;
-  content?: string;
-}
-
-interface StoredMessage {
-  id?: string;
-  role: string;
-  content: string;
-  date?: string;
-  timestamp?: string;
-  attachments?: StoredAttachment[];
-}
-
-function isRawComposerInput(content: string): boolean {
-  return /^\s*\//.test(content) || /(^|\s)@[A-Za-z0-9_-]+/.test(content);
-}
-
-/** Whether a JSONL-derived user turn (a) and a stored one (b) are the same
- *  request despite omp rewriting the delivered prompt. */
-function userTurnsRelate(a: string, b: string): boolean {
-  if (a === b || a.startsWith(b) || b.startsWith(a)) return true;
-  // `@agent` is delivered to omp as a task-tool delegation prompt.
-  if (a.startsWith('Use the task tool to delegate this request') && /(^|\s)@[A-Za-z0-9_-]+/.test(b)) {
-    return true;
-  }
-  // `/skill:<name> <args>`: the JSONL only records a synthesized `/skill:<name>`.
-  const token = a.split(' ')[0];
-  return a.startsWith('/skill:') && Boolean(token) && b.startsWith(token);
-}
-
-/** Merge user turns and attachments from the chamber DB copy onto the
- *  JSONL-loaded messages. omp's JSONL rewrites raw composer input (`@agent` →
- *  task-tool prompt, `/skill:a b` → `/skill:a`) and writes no user entry at all
- *  for `/command` turns, so the raw DB copy restores both the displayed text
- *  and the missing bubbles. */
-function mergeOmpAttachments(
-  messages: StoredMessage[],
-  storedMessagesJson: string | undefined,
-): StoredMessage[] {
-  if (!storedMessagesJson) return messages;
-  let stored: StoredMessage[] = [];
-  try {
-    stored = JSON.parse(storedMessagesJson);
-  } catch {
-    return messages;
-  }
-  if (!Array.isArray(stored)) return messages;
-  const storedUsers = stored.filter((m) => m?.role === 'user' && typeof m.content === 'string');
-
-  const jsonlIndex = new Map<string, number>();
-  messages.forEach((m, index) => {
-    if (m.id) jsonlIndex.set(m.id, index);
-  });
-
-  const used = new Set<number>();
-  const merged = messages.map((m) => {
-    if (m.role !== 'user') return m;
-    const storedIndex = storedUsers.findIndex((s, i) => !used.has(i) && userTurnsRelate(m.content, s.content));
-    if (storedIndex === -1) return m;
-    used.add(storedIndex);
-    const storedMsg = storedUsers[storedIndex];
-    const content = storedMsg.content !== m.content && isRawComposerInput(storedMsg.content)
-      ? storedMsg.content
-      : m.content;
-    const attachments = m.attachments?.length ? m.attachments : storedMsg.attachments;
-    const next = { ...m, content };
-    return attachments?.length ? { ...next, attachments } : next;
-  });
-
-  // Unmatched raw turns are anchored before the next stored message the JSONL
-  // still carries; splice highest-anchor-first so earlier indices stay valid.
-  const insertions = new Map<number, StoredMessage[]>();
-  storedUsers.forEach((storedMsg, userIndex) => {
-    if (used.has(userIndex) || !isRawComposerInput(storedMsg.content)) return;
-    if (storedMsg.id && jsonlIndex.has(storedMsg.id)) return;
-    let anchor = merged.length;
-    for (let i = stored.indexOf(storedMsg) + 1; i < stored.length; i += 1) {
-      const id = stored[i]?.id;
-      const found = typeof id === 'string' ? jsonlIndex.get(id) : undefined;
-      if (found !== undefined) {
-        anchor = found;
-        break;
-      }
-    }
-    const group = insertions.get(anchor);
-    if (group) group.push(storedMsg);
-    else insertions.set(anchor, [storedMsg]);
-  });
-  for (const anchor of [...insertions.keys()].sort((a, b) => b - a)) {
-    const group = insertions.get(anchor);
-    if (group) merged.splice(anchor, 0, ...group);
-  }
-
-  const byContent = new Map<string, StoredAttachment[]>();
-  for (const m of stored) {
-    if (m?.role === 'user' && Array.isArray(m.attachments) && m.attachments.length > 0) {
-      byContent.set(m.content, m.attachments);
-    }
-  }
-  return merged.map((m) => {
-    if (m.role !== 'user' || m.attachments?.length) return m;
-    // The JSONL content may carry inlined text-file blocks appended to the
-    // original prompt, so match by prefix instead of exact equality.
-    const atts = byContent.get(m.content)
-      ?? [...byContent.entries()].find(([storedContent]) =>
-          m.content.startsWith(storedContent) || storedContent.startsWith(m.content)
-        )?.[1];
-    return atts ? { ...m, attachments: atts } : m;
-  });
-}
-
 /** Slice a fully loaded message list into the requested tail window. */
 function windowMessages<T>(
   messages: T[],

package/src/server/routes/chat/turns.ts

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Full-history user-turn index for the timeline jump rail.
+ *
+ * The timeline only mounts a window of a long session (the newest 120 messages
+ * plus whatever "Load earlier messages" pulled in), so a rail built from the
+ * mounted rows shows a fraction of the conversation and cannot reach a turn
+ * that was never paged in. This endpoint answers the same id/position question
+ * the timeline does — the JSONL messages with the chamber DB overlay merged —
+ * but for the WHOLE session, and strips each row down to what a tick needs.
+ *
+ * Positions are indices into that full merged list, which is exactly the list
+ * `GET /api/chat/:sessionId` pages through with `?before=`: a rail click pages
+ * windows from that index until the target row is mounted, so the cursor the
+ * rail carries is the same coordinate space the loader uses.
+ */
+
+import { json } from '@/server/lib/remix-compat';
+import type { LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { getDb } from '@/server/db.server';
+import { getSessionData } from '@/client/data/mock/chat';
+import { isMockMode } from '@/server/mock.server';
+import { findSessionFileById } from '@/server/lib/omp/session/locator';
+import { loadSessionMessages } from '@/server/lib/omp/session/messages';
+import { mergeOmpAttachments } from '@/server/lib/omp/session/merge-stored';
+import { TURN_PREVIEW_CHARS } from '@/shared/lib/chat/timeline/turns';
+import type { UserTurnRef } from '@/shared/types/chat';
+
+/** One rail entry per user row: its id (the DOM jump target), its position in
+ *  the full list (the paging cursor), and enough text for the tooltip. */
+function toUserTurns(messages: Array<{ id?: string; role?: string; content?: string; date?: string; timestamp?: string }>): UserTurnRef[] {
+  const turns: UserTurnRef[] = [];
+  messages.forEach((message, index) => {
+    if (message?.role !== 'user') return;
+    const content = typeof message.content === 'string' ? message.content : '';
+    turns.push({
+      id: typeof message.id === 'string' && message.id ? message.id : `turn-${index}`,
+      index,
+      preview: content.slice(0, TURN_PREVIEW_CHARS),
+      date: message.date,
+      timestamp: message.timestamp,
+    });
+  });
+  return turns;
+}
+
+export async function loader({ params }: LoaderFunctionArgs) {
+  const { sessionId } = params;
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+
+  const mock = isMockMode();
+  try {
+    if (!mock) {
+      const filePath = await findSessionFileById(sessionId);
+      if (filePath) {
+        const messages = await loadSessionMessages(filePath);
+        const db = await getDb();
+        const overlay = await db.get('SELECT messages FROM chat_sessions WHERE session_id = ?', [sessionId]);
+        const overlaid = mergeOmpAttachments(messages, overlay?.messages);
+        return json({ turns: toUserTurns(overlaid), total: overlaid.length, source: 'omp-jsonl' });
+      }
+    }
+
+    // Chamber-created sessions (mock or synthetic ids) answer from the DB copy,
+    // mirroring the timeline loader's fallback.
+    const db = await getDb();
+    const existing = await db.get('SELECT messages FROM chat_sessions WHERE session_id = ?', [sessionId]);
+    let messages: unknown[] = [];
+    if (existing?.messages) {
+      try {
+        const parsed: unknown = JSON.parse(existing.messages);
+        if (Array.isArray(parsed)) messages = parsed;
+      } catch {
+        messages = [];
+      }
+    } else if (mock) {
+      messages = getSessionData(sessionId)?.messages ?? [];
+    }
+    return json({ turns: toUserTurns(messages as Array<{ role?: string; content?: string }>), total: messages.length, source: mock ? 'mock' : 'db' });
+  } catch (error: unknown) {
+    return json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 });
+  }
+}

package/src/server/routes/fs/index.ts

@@ -1,5 +1,6 @@
 import { bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
-import { browseDirectories, listDirectory, listFiles, readFile } from '@/server/routes/fs/read';
+import { browseDirectories, listDirectory, listFiles, readFile, readReferencedFile } from '@/server/routes/fs/read';
+import { serveRawFile } from '@/server/routes/fs/raw';
 import * as fsAction from '@/server/routes/fs/action';
 import * as fsGit from '@/server/routes/fs/git';
 import * as fsReplace from '@/server/routes/fs/replace';
@@ -16,4 +17,6 @@ export const fsBindings: HandlerBinding[] = [
   { method: 'GET', path: '/api/fs/dir', handler: listDirectory },
   { method: 'GET', path: '/api/fs/list', handler: listFiles },
   { method: 'GET', path: '/api/fs/read', handler: readFile },
+  { method: 'GET', path: '/api/fs/read-reference', handler: readReferencedFile },
+  { method: 'GET', path: '/api/fs/raw', handler: serveRawFile },
 ];

package/src/server/routes/fs/raw.ts

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { json, type LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { errorResponse } from '@/server/lib/route-adapter';
+import { isMockMode } from '@/server/mock.server';
+import { getDefaultFsRoot, resolveRoot, resolveWithinRoot } from '@/server/lib/fs/root';
+import { getImageMimeType } from '@/shared/lib/fs/file-kind';
+
+/**
+ * GET /api/fs/raw?path=<rel>&root=<abs>&repo=<rel> — the file's bytes, verbatim.
+ *
+ * Images reach the editor through this route instead of `/api/fs/read`, which
+ * answers with JSON and therefore cannot carry them: a PNG's bytes are not
+ * UTF-8, so `Bun.file().text()` returned replacement characters and the panel
+ * painted mojibake. The browser can only paint a picture from a real byte
+ * stream with a real `content-type`, which is exactly what this returns.
+ *
+ * Scope resolution is identical to `/api/fs/read` (same root allow-list, same
+ * `resolveWithinRoot` containment), so a path that reads as text can be served
+ * as bytes and vice versa.
+ */
+export async function serveRawFile({ request }: LoaderFunctionArgs) {
+  const url = new URL(request.url);
+  const filePath = url.searchParams.get('path');
+
+  if (!filePath) {
+    return json({ error: 'Missing path' }, { status: 400 });
+  }
+
+  let baseDir = await resolveRoot(url.searchParams.get('root'), await getDefaultFsRoot(isMockMode()));
+
+  const repo = url.searchParams.get('repo');
+  if (repo && repo !== '.') {
+    const repoDir = resolveWithinRoot(baseDir, repo);
+    if (repoDir) {
+      baseDir = repoDir;
+    }
+  }
+
+  const cleanPath = filePath.replace(/^\/+/, '');
+  const fullPath = resolveWithinRoot(baseDir, cleanPath);
+
+  if (!fullPath) {
+    return json({ error: 'Invalid path' }, { status: 403 });
+  }
+
+  try {
+    const file = Bun.file(fullPath);
+    if (!(await file.exists())) {
+      return json({ error: 'File not found' }, { status: 404 });
+    }
+    const stat = await file.stat();
+    if (stat.isDirectory()) {
+      return json({ error: 'Cannot read a directory' }, { status: 400 });
+    }
+
+    // `no-store` because a raw read is how a refreshed view sees a file that
+    // changed on disk under the same path; an immutable image URL would pin the
+    // old bytes for the life of the tab.
+    return new Response(file.stream(), {
+      headers: {
+        'content-type': getImageMimeType(cleanPath) ?? 'application/octet-stream',
+        'content-length': String(stat.size),
+        'content-disposition': `inline; filename="${safeFileName(cleanPath)}"`,
+        'cache-control': 'no-store',
+      },
+    });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+
+/**
+ * The filename for `content-disposition`. Only ASCII-printable characters
+ * survive: the header is latin-1, and a non-ASCII byte (or a quote) in a
+ * filename would either corrupt the header or break out of the quoted string.
+ */
+function safeFileName(cleanPath: string): string {
+  const base = cleanPath.split('/').pop() ?? 'file';
+  const ascii = base.replace(/[^\x20-\x7e]/g, '_').replace(/["\\]/g, '_');
+  return ascii || 'file';
+}

package/src/server/routes/fs/read.ts

@@ -10,8 +10,9 @@ import { dirname, isAbsolute, join, resolve } from 'path';
 import fs from 'fs';
 import path from 'path';
 import { isMockMode } from '@/server/mock.server';
-import { getDefaultFsRoot, resolveRoot, resolveWithinRoot } from '@/server/lib/fs/root';
+import { getDefaultFsRoot, resolveReferencedPath, resolveRoot, resolveWithinRoot } from '@/server/lib/fs/root';
 import { collectIgnoredPaths } from '@/server/lib/fs/git-ignore';
+import { getImageMimeType } from '@/shared/lib/fs/file-kind';
 
 /**
  * GET /api/fs/browse?path=<abs> — list subdirectories of a folder for the
@@ -230,7 +231,6 @@ export async function readFile({ request }: LoaderFunctionArgs) {
   if (!filePath) {
     return json({ error: 'Missing path' }, { status: 400 });
   }
-
   let baseDir = await resolveRoot(url.searchParams.get('root'), await getDefaultFsRoot(isMockMode()));
 
   // If repo is specified (e.g. nested git project), resolve inside the repo
@@ -254,13 +254,68 @@ export async function readFile({ request }: LoaderFunctionArgs) {
     if (!(await file.exists())) {
       return json({ error: 'File not found' }, { status: 404 });
     }
-    if ((await file.stat()).isDirectory()) {
+    const stat = await file.stat();
+    if (stat.isDirectory()) {
       return json({ error: 'Cannot read a directory' }, { status: 400 });
     }
 
+    // An image has no text: decoding its bytes here returned replacement
+    // characters, which every reader painted as mojibake. Every in-repo reader
+    // branches on the extension first and takes `/api/fs/raw`, so this answers
+    // the remaining callers with the real reason instead of garbage.
+    if (getImageMimeType(cleanPath)) {
+      return json({ error: 'Image files are served by /api/fs/raw' }, { status: 400 });
+    }
+
     const content = await file.text();
     return json({ content });
   } catch (error) {
     return errorResponse(error);
   }
 }
+
+/**
+ * GET /api/fs/read-reference?path=<abs path or URL> — read a file a drop or a
+ * link pointed at.
+ *
+ * A download dragged out of a web page (WhatsApp Web, Gmail, Slack) carries no
+ * bytes, only a reference, and the page cannot fetch a `file://` path itself.
+ * The path is therefore resolved against the same allow-list that governs a
+ * client-supplied `root` — the app root, a path beneath it, or a registered
+ * workspace — so this cannot be used to read an arbitrary file.
+ *
+ * Text only: an image or binary has no string form to return, and the drop's
+ * own `File` is the path that carries those.
+ */
+export async function readReferencedFile({ request }: LoaderFunctionArgs) {
+  const url = new URL(request.url);
+  const reference = url.searchParams.get('path');
+  if (!reference) {
+    return json({ error: 'Missing path' }, { status: 400 });
+  }
+
+  // A remote reference is not fetched here: the chamber has no policy for
+  // outbound requests and a drag from a page is not a reason to add one.
+  if (/^https?:\/\//i.test(reference)) {
+    return json({ error: 'Remote references are not supported' }, { status: 400 });
+  }
+
+  const filePath = await resolveReferencedPath(reference.replace(/^file:\/\//, ''));
+  if (!filePath) {
+    return json({ error: 'File not found' }, { status: 404 });
+  }
+
+  try {
+    const file = Bun.file(filePath);
+    const stat = await file.stat();
+    if (stat.isDirectory()) {
+      return json({ error: 'Cannot read a directory' }, { status: 400 });
+    }
+    if (getImageMimeType(filePath)) {
+      return json({ error: 'Image files are served by /api/fs/raw' }, { status: 400 });
+    }
+    return json({ content: await file.text(), name: path.basename(filePath) });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}

package/src/server/routes/index.ts

@@ -2,6 +2,8 @@ import { Elysia } from 'elysia';
 import { mountBindings, type HandlerBinding } from '@/server/lib/route-adapter';
 import { agentBindings } from '@/server/routes/agent';
 import { agentWsRoutes } from '@/server/routes/agent/ws';
+import { btwBindings } from '@/server/routes/btw';
+import { btwWsRoutes } from '@/server/routes/btw/ws';
 import { chatBindings } from '@/server/routes/chat';
 import { sessionsBindings } from '@/server/routes/sessions';
 import { settingsBindings } from '@/server/routes/settings';
@@ -20,6 +22,7 @@ import { wellKnownBindings } from '@/server/routes/well-known';
 
 const allBindings: HandlerBinding[] = [
   ...agentBindings,
+  ...btwBindings,
   ...chatBindings,
   ...sessionsBindings,
   ...settingsBindings,
@@ -36,4 +39,7 @@ const allBindings: HandlerBinding[] = [
   ...wellKnownBindings,
 ];
 
-export const apiRoutes = mountBindings(new Elysia(), allBindings).use(agentWsRoutes).use(terminalWsRoutes);
+export const apiRoutes = mountBindings(new Elysia(), allBindings)
+  .use(agentWsRoutes)
+  .use(btwWsRoutes)
+  .use(terminalWsRoutes);