@zgeoff/atc 2.8.2 → 2.9.0

package/README.md

@@ -130,6 +130,11 @@ installs in detail.
   A Claude or Codex session that is already running loads the server only after it restarts. A
   running Grok session loads it when you press `r` in its `/mcps` list.
 
+- `atc mcp --http` serves the same tools over HTTP behind OAuth, so a hosted assistant such as
+  ChatGPT or Claude.ai can reach your sessions with the scopes you approve. Add each assistant with
+  `atc clients add`, approve each connection with the code printed in the server's terminal, and
+  list or revoke grants with `atc grants`. [Remote MCP](./docs/architecture/remote-mcp.md) covers
+  it.
 - A Claude session takes messages from other tools. `atc_session_message` queues one, and the
   session reads it in a new turn, or inside the turn it is running. `atc_message_get` returns the
   reply once that turn ends. The [protocol](./docs/architecture/protocol.md#messages) covers the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "2.8.2",
+  "version": "2.9.0",
   "description": "Terminal control tower for coding-agent sessions",
   "homepage": "https://github.com/zgeoff/atc#readme",
   "bugs": "https://github.com/zgeoff/atc/issues",
@@ -37,20 +37,23 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.222",
+    "@better-auth/mcp": "1.7.6",
+    "@better-auth/oauth-provider": "1.7.6",
     "@xterm/addon-serialize": "0.14.0",
     "@xterm/headless": "6.0.0",
+    "better-auth": "1.7.6",
     "bun-pty": "0.4.10",
     "citty": "0.2.2",
     "kysely": "0.29.5",
     "ts-pattern": "5.9.0",
     "xstate": "5.32.5",
-    "zod": "4.4.3"
+    "zod": "4.6.5"
   },
   "devDependencies": {
     "@commitlint/cli": "21.2.0",
     "@stylistic/eslint-plugin": "5.10.0",
     "@tsconfig/strictest": "2.0.8",
-    "@types/bun": "1.3.14",
+    "@types/bun": "1.4.2",
     "@zgeoff/bun-test-extended": "0.0.4",
     "@zgeoff/format-codemod": "0.0.8",
     "@zgeoff/oxlint-config": "0.0.6",

package/src/agents/agent-adapter.ts

@@ -106,7 +106,9 @@ interface HeadlessRunRequest {
 
 interface HeadlessRunEvents {
   readonly onOutput: (text: string) => void;
-  readonly onDone: (summary: string) => void;
+
+  // The turn's whole final message.
+  readonly onDone: (result: string) => void;
   readonly onNeedsYou: (msg: string) => void;
 }
 

package/src/cli.ts

@@ -2,6 +2,8 @@
 // `statusline` are the commands injected into wrangled sessions.
 import { defineCommand, runMain } from 'citty';
 import pkg from '../package.json';
+import { collectRedirectURIs } from './collect-redirect-uris';
+import { parsePort } from './parse-port';
 import { getBuild } from './shared/get-build';
 
 const main = defineCommand({
@@ -27,12 +29,120 @@ const main = defineCommand({
       defineCommand({
         meta: {
           name: 'mcp',
-          description: 'Run an MCP server over stdio exposing the fleet as tools',
+          description:
+            'Run an MCP server exposing the fleet as tools: over stdio, or with --http behind OAuth',
         },
-        async run() {
-          const server = await import('./mcp-server');
+        args: {
+          http: {
+            type: 'boolean',
+            default: false,
+            description: 'Serve MCP over HTTP behind OAuth',
+          },
+          host: {
+            type: 'string',
+            description: 'Address to bind with --http (default 127.0.0.1)',
+          },
+          port: { type: 'string', description: 'Port to listen on with --http (default 8414)' },
+          'public-url': {
+            type: 'string',
+            description:
+              'Origin clients reach the --http server at, such as https://mcp.example.com',
+          },
+        },
+        async run(ctx) {
+          if (!ctx.args.http) {
+            const server = await import('./mcp-server');
+
+            await server.runMCPServer(getBuild());
+
+            return;
+          }
+
+          const port = ctx.args.port === undefined ? null : parsePort(ctx.args.port);
+
+          if (port !== null && !port.ok) {
+            console.error(`atc mcp --http: ${port.message}`);
+            process.exit(1);
+          }
+
+          const http = await import('./mcp-http-server');
+
+          await http.runMCPHTTPServer(getBuild(), {
+            host: ctx.args.host ?? null,
+            port: port === null ? null : port.port,
+            publicURL: ctx.args['public-url'] ?? null,
+          });
+        },
+      }),
+    clients: () =>
+      defineCommand({
+        meta: {
+          name: 'clients',
+          description: 'List, add, or remove the clients that may connect to atc mcp --http',
+        },
+        default: 'list',
+        subCommands: {
+          list: () =>
+            defineCommand({
+              meta: { name: 'list', description: 'List the clients', hidden: true },
+              async run() {
+                const clients = await import('./clients');
+
+                await clients.runClients({ kind: 'list' });
+              },
+            }),
+          add: () =>
+            defineCommand({
+              meta: { name: 'add', description: 'Add a client and print its client ID' },
+              args: {
+                name: { type: 'positional', required: true, description: 'The client name' },
+                'redirect-uri': {
+                  type: 'string',
+                  required: true,
+                  description: 'A redirect URI the client returns to; repeat for more',
+                },
+              },
+              async run(ctx) {
+                const clients = await import('./clients');
+
+                await clients.runClients({
+                  kind: 'add',
+                  name: ctx.args.name,
+                  redirectURIs: collectRedirectURIs(ctx.rawArgs),
+                });
+              },
+            }),
+          remove: () =>
+            defineCommand({
+              meta: {
+                name: 'remove',
+                description: 'Remove a client and revoke every grant it holds',
+              },
+              args: {
+                id: { type: 'positional', required: true, description: 'The client ID' },
+              },
+              async run(ctx) {
+                const clients = await import('./clients');
+
+                await clients.runClients({ kind: 'remove', clientID: ctx.args.id });
+              },
+            }),
+        },
+      }),
+    grants: () =>
+      defineCommand({
+        meta: {
+          name: 'grants',
+          description:
+            'List the grants atc mcp --http clients hold, or revoke one with --revoke <id>',
+        },
+        args: {
+          revoke: { type: 'string', description: 'The ID of a grant to revoke' },
+        },
+        async run(ctx) {
+          const grants = await import('./grants');
 
-          await server.runMCPServer(getBuild());
+          await grants.runGrants(ctx.args.revoke ?? null);
         },
       }),
     daemon: () =>

package/src/clients.ts

@@ -0,0 +1,82 @@
+import { mkdirSync } from 'node:fs';
+import { collectClients } from './mcp/collect-clients';
+import { isAllowedRedirectURI } from './mcp/is-allowed-redirect-uri';
+import { openMCPAuth } from './mcp/open-mcp-auth';
+import { removeClient } from './mcp/remove-client';
+import { mcpAuthDBFile, stateDir } from './shared/config';
+import { normalizeClientName } from './shared/normalize-client-name';
+
+type ClientsAction =
+  | { readonly kind: 'list' }
+  | { readonly kind: 'add'; readonly name: string; readonly redirectURIs: readonly string[] }
+  | { readonly kind: 'remove'; readonly clientID: string };
+
+/**
+ * Runs `atc clients`: lists the clients that may connect to `atc mcp --http`,
+ * adds one, or removes one along with every token and consent it holds. It
+ * opens the authorization server's database directly, so it works whether or
+ * not the server is running.
+ */
+export async function runClients(action: ClientsAction): Promise<void> {
+  if (action.kind === 'add') {
+    const refused = action.redirectURIs.find((uri) => !isAllowedRedirectURI(uri));
+
+    if (action.redirectURIs.length === 0 || refused !== undefined) {
+      const message =
+        refused === undefined
+          ? 'atc clients add: give at least one --redirect-uri'
+          : `atc clients add: '${refused}' is not a redirect URI atc accepts; use https, or http on a loopback host, with no fragment`;
+
+      console.error(message);
+      process.exit(1);
+    }
+  }
+
+  mkdirSync(stateDir, { recursive: true });
+
+  const store = await openMCPAuth({ dbPath: mcpAuthDBFile, origin: null });
+
+  try {
+    if (action.kind === 'add') {
+      const name = normalizeClientName(action.name);
+
+      const created = await store.auth.api.createFixedClient({
+        body: { name, redirectURIs: [...action.redirectURIs] },
+      });
+
+      console.log(`Added ${name}. Its client ID is ${created.clientID}`);
+
+      return;
+    }
+
+    if (action.kind === 'remove') {
+      const removed = await removeClient(store.db, action.clientID);
+
+      if (!removed) {
+        console.error(`atc clients remove: no client has the ID '${action.clientID}'`);
+
+        process.exitCode = 1;
+
+        return;
+      }
+
+      console.log(`Removed client ${action.clientID} and revoked every grant it held`);
+
+      return;
+    }
+
+    const clients = await collectClients(store.db);
+
+    if (clients.length === 0) {
+      console.log('No clients. Add one with: atc clients add <name> --redirect-uri <uri>');
+
+      return;
+    }
+
+    for (const client of clients) {
+      console.log(`${client.clientID}  ${client.name}  ${client.redirectURIs.join(' ')}`);
+    }
+  } finally {
+    await store.close();
+  }
+}

package/src/collect-redirect-uris.ts

@@ -0,0 +1,16 @@
+/**
+ * Every `--redirect-uri` value in a command line, in order, whether given as
+ * `--redirect-uri <uri>` or `--redirect-uri=<uri>`. The flag can repeat, and
+ * the argument parser keeps only its last value.
+ */
+export function collectRedirectURIs(rawArgs: readonly string[]): readonly string[] {
+  return rawArgs.flatMap((arg, index) => {
+    if (arg.startsWith('--redirect-uri=')) {
+      return [arg.slice('--redirect-uri='.length)];
+    }
+
+    const next = rawArgs[index + 1];
+
+    return arg === '--redirect-uri' && next !== undefined ? [next] : [];
+  });
+}

package/src/daemon/build-fleet-events.ts

@@ -1,4 +1,5 @@
 import { encodeCursor } from '../protocol/encode-cursor';
+import type { MessageID } from '../shared/message-id';
 import type { StoredEvent } from '../store/state-store';
 import type { SessionDescriptor } from './sessions';
 
@@ -9,6 +10,12 @@ export interface FleetEvent {
   readonly name: string | null;
   readonly kind: string;
   readonly detail: string | null;
+
+  // The message id on a message status event, for message.get.
+  readonly message?: MessageID;
+
+  // The report label on a report event.
+  readonly label?: string;
 }
 
 export function buildFleetEvents(
@@ -30,6 +37,8 @@ export function buildFleetEvents(
       name: live?.name ?? null,
       kind: row.kind,
       detail: row.detail,
+      ...(row.message === undefined ? {} : { message: row.message }),
+      ...(row.label === undefined ? {} : { label: row.label }),
     };
   });
 }

package/src/daemon/build-message-trail-entry.ts

@@ -0,0 +1,54 @@
+import { truncateDetail } from '../agents/truncate-detail';
+import type { AgentSessionID } from '../shared/agent-session-id';
+import type { SessionID } from '../shared/session-id';
+import type { MessageRecord, MessageStatus } from '../store/message-record';
+import type { TrailEntry } from '../store/trail-entry';
+
+/**
+ * The trail entry for one message status change, addressed like its SessionMessage
+ * broadcast. It is stamped with the status's own time and the owning session's agent
+ * session id, falling back to the one the message carries, and the detail previews
+ * the answer once there is one, else the text.
+ */
+export function buildMessageTrailEntry(
+  sessionID: SessionID,
+  agentSessionID: AgentSessionID | undefined,
+  record: MessageRecord,
+): TrailEntry {
+  const previewText = record.status === 'answered' ? (record.answer ?? record.text) : record.text;
+
+  return {
+    at: pickStatusTime(record),
+    atcID: sessionID,
+    agentSessionID: agentSessionID ?? record.agentSessionID ?? null,
+    kind: pickMessageKind(record.status),
+    message: record.id,
+    detail: truncateDetail(previewText),
+  };
+}
+
+function pickStatusTime(record: MessageRecord): number {
+  if (record.status === 'answered') {
+    return record.answeredAt ?? record.sentAt;
+  }
+
+  if (record.status === 'delivered') {
+    return record.deliveredAt ?? record.sentAt;
+  }
+
+  return record.sentAt;
+}
+
+function pickMessageKind(
+  status: MessageStatus,
+): 'message-accepted' | 'message-delivered' | 'message-answered' {
+  if (status === 'answered') {
+    return 'message-answered';
+  }
+
+  if (status === 'delivered') {
+    return 'message-delivered';
+  }
+
+  return 'message-accepted';
+}

package/src/daemon/build-report-trail-entry.ts

@@ -0,0 +1,25 @@
+import { truncateDetail } from '../agents/truncate-detail';
+import type { AgentSessionID } from '../shared/agent-session-id';
+import type { SessionID } from '../shared/session-id';
+import type { TrailEntry } from '../store/trail-entry';
+import type { NoteReport } from './parse-report';
+
+/**
+ * The trail entry for one note a session reported, carrying its label and a
+ * preview of its text.
+ */
+export function buildReportTrailEntry(
+  sessionID: SessionID,
+  agentSessionID: AgentSessionID | undefined,
+  report: Readonly<NoteReport>,
+  reportedAt: number,
+): TrailEntry {
+  return {
+    at: reportedAt,
+    atcID: sessionID,
+    agentSessionID: agentSessionID ?? null,
+    kind: 'report',
+    label: report.label,
+    detail: truncateDetail(report.text),
+  };
+}

package/src/daemon/build-session-message-event.ts

@@ -11,7 +11,6 @@ import type { MessageRecord } from '../store/message-record';
  * broadcast stays small; `message.get` returns the full message. Delivery
  * and answer fields appear only once they are set.
  */
-// oxlint-disable-next-line prefer-readonly-parameter-types -- every field is readonly; the branded id has no readonly form to wrap it in
 export function buildSessionMessageEvent(sessionID: SessionID, record: MessageRecord): EventMsg {
   return {
     v: PROTOCOL_V,

package/src/daemon/daemon.ts

@@ -8,9 +8,12 @@ import { truncateToBytes } from '../shared/truncate-to-bytes';
 import type { MessageOwner } from '../store/message-owner';
 import type { MessageRecord } from '../store/message-record';
 import { StateStore } from '../store/state-store';
+import type { TrailEntry } from '../store/trail-entry';
 import { ANSWER_BYTE_CAP } from './answer-byte-cap';
 import { AttachRegistry } from './attach-registry';
 import { buildFleetEvents } from './build-fleet-events';
+import { buildMessageTrailEntry } from './build-message-trail-entry';
+import { buildReportTrailEntry } from './build-report-trail-entry';
 import { buildSessionEvent } from './build-session-event';
 import { buildSessionMessageEvent } from './build-session-message-event';
 import { buildSessionReportEvent } from './build-session-report-event';
@@ -89,6 +92,9 @@ export interface DaemonOptions {
 
 export interface DaemonHandle {
   readonly stop: () => Promise<void>;
+
+  // How many client-protocol connections are open right now.
+  readonly countClients: () => number;
 }
 
 // How long a started Claude session may go without a tap before a message to
@@ -150,6 +156,27 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
   const registry = new PermissionRegistry();
   const eventSignal = new EventSignal();
 
+  // A trail write that fails never fails the message request or report behind it.
+  const recordTrailEntry = async (entry: TrailEntry) => {
+    try {
+      await store.recordTrailEntry(entry);
+    } catch {
+      return;
+    }
+
+    eventSignal.emit();
+  };
+
+  // Notes a message status change in the trail before broadcasting it, so a
+  // client reading the trail on the broadcast finds the change already there.
+  const recordMessageStatus = async (sessionID: SessionID, record: MessageRecord) => {
+    const s = mgr.sessions.find((x) => x.id === sessionID);
+
+    await recordTrailEntry(buildMessageTrailEntry(sessionID, s?.agentSessionID, record));
+
+    emitEvent(buildSessionMessageEvent(sessionID, record), findHookScope(sessionID));
+  };
+
   registry.onRequested = (req) => {
     emitEvent(
       {
@@ -187,7 +214,6 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
   // Hands one pending message to the session's tap, once, and reports whether
   // it did. The event goes to the tap connection alone: it never reaches
   // other clients, the events socket, or hooks.
-  // oxlint-disable-next-line prefer-readonly-parameter-types -- every field is readonly; the branded id has no readonly form to wrap it in
   const sendInboxMessage = (sessionID: SessionID, record: MessageRecord): boolean => {
     const tap = taps.claimDelivery(sessionID, record.id);
 
@@ -242,8 +268,13 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
 
       if (sender !== undefined) {
         const capped = { ...report, text: truncateToBytes(report.text, ANSWER_BYTE_CAP) };
+        const reportedAt = Date.now();
+
+        await recordTrailEntry(
+          buildReportTrailEntry(sender.id, sender.agentSessionID, capped, reportedAt),
+        );
 
-        emitEvent(buildSessionReportEvent(sender.id, capped, Date.now()), findHookScope(sender.id));
+        emitEvent(buildSessionReportEvent(sender.id, capped, reportedAt), findHookScope(sender.id));
       }
 
       return;
@@ -261,7 +292,7 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
       );
 
       if (answered !== null) {
-        emitEvent(buildSessionMessageEvent(e.atcId, answered), findHookScope(e.atcId));
+        await recordMessageStatus(e.atcId, answered);
       }
     } catch {}
   };
@@ -496,6 +527,21 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
     eventSignal.emit();
   };
 
+  // A headless turn has no terminal hooks of its own, so the daemon writes
+  // its start and end to the trail under a synthetic event name.
+  const recordHeadlessTurnEvent = (sessionID: SessionID, ev: Readonly<AdapterEvent>) => {
+    const s = mgr.sessions.find((x) => x.id === sessionID);
+
+    void recordHookEvent(
+      {
+        atcId: sessionID,
+        event: 'HeadlessTurn',
+        payload: s?.agentSessionID === undefined ? {} : { session_id: s.agentSessionID },
+      },
+      ev,
+    );
+  };
+
   const reporter = startHookServer((e) => {
     if (e.event === 'Report') {
       void applyReport(e);
@@ -503,11 +549,16 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
       return;
     }
 
-    const previousAgentSessionID = mgr.sessions.find((s) => s.id === e.atcId)?.agentSessionID;
+    const before = mgr.sessions.find((s) => s.id === e.atcId);
+    const previousAgentSessionID = before?.agentSessionID;
     const ev = mgr.applyHook(e);
 
+    // A headless session's trail comes from its runs alone: hook reports from
+    // its dying terminal, or from a run's own CLI, stay out of it.
+    const trailEvent = before?.kind === 'headless' ? null : ev;
+
     if (e.event !== 'Statusline') {
-      void recordHookEvent(e, ev);
+      void recordHookEvent(e, trailEvent);
     }
 
     const kind = ev?.kind ?? null;
@@ -516,6 +567,7 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
 
     if (currentAgentSessionID !== undefined && currentAgentSessionID !== previousAgentSessionID) {
       void store.updateMessageOwner(e.atcId, previousAgentSessionID, currentAgentSessionID);
+      void store.updateTrailOwner(e.atcId, currentAgentSessionID);
     }
 
     if (kind === 'ended') {
@@ -633,7 +685,8 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
         prompt,
         settleMs: opts.ejectSettleMs ?? 4000,
         runtime,
-        startHeadlessTurn: (sid, p) => startHeadlessTurn(mgr, findRuntime, sid, p),
+        startHeadlessTurn: (sid, p) =>
+          startHeadlessTurn(mgr, findRuntime, sid, p, recordHeadlessTurnEvent),
       });
 
       return 'ok';
@@ -743,7 +796,15 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
           return 'busy';
         }
 
-        return startHeadlessTurn(mgr, findRuntime, sessionID, data.trimEnd()) ? 'ok' : 'dead';
+        return startHeadlessTurn(
+          mgr,
+          findRuntime,
+          sessionID,
+          data.trimEnd(),
+          recordHeadlessTurnEvent,
+        )
+          ? 'ok'
+          : 'dead';
       }
 
       if (s.pty === null) {
@@ -886,12 +947,12 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
 
       try {
         await store.writeMessage(record);
+
+        await recordMessageStatus(sessionID, record);
       } finally {
         written.resolve();
       }
 
-      emitEvent(buildSessionMessageEvent(sessionID, record), findHookScope(sessionID));
-
       await drainInbox(sessionID);
 
       return record;
@@ -948,7 +1009,7 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
       void drainInbox(sessionID);
 
       if (delivered !== null) {
-        emitEvent(buildSessionMessageEvent(sessionID, delivered), findHookScope(sessionID));
+        await recordMessageStatus(sessionID, delivered);
 
         return delivered;
       }
@@ -1014,7 +1075,7 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
     }
   };
 
-  return { stop: stopDaemon };
+  return { stop: stopDaemon, countClients: () => clients.size };
 }
 
 // Tells a tap its subscription is over so the `atc tap` process behind it

package/src/daemon/sessions.ts

@@ -2,6 +2,7 @@ import { writeFileSync } from 'node:fs';
 import { spawn } from 'bun-pty';
 import type { IPty } from 'bun-pty';
 import type { AdapterEvent, AgentAdapter, AgentID } from '../agents/agent-adapter';
+import { truncateDetail } from '../agents/truncate-detail';
 import type { AgentSessionID } from '../shared/agent-session-id';
 import { collectCleanEnv } from '../shared/collect-clean-env';
 import { socketPath, statusFile } from '../shared/config';
@@ -302,7 +303,9 @@ export class SessionManager {
     return true;
   }
 
-  updateSurfaceState(id: SessionID, state: SessionState, msg: string) {
+  // A result, when given, becomes the session's latest result the way a
+  // terminal turn's final message does.
+  updateSurfaceState(id: SessionID, state: SessionState, msg: string, result?: string) {
     const s = this.sessions.find((x) => x.id === id);
 
     if (!s || s.kind !== 'headless') {
@@ -313,6 +316,15 @@ export class SessionManager {
     s.lastMsg = msg;
     s.unread = this.focusedId !== s.id;
 
+    if (result !== undefined) {
+      s.result = truncateToBytes(result, 16_384);
+      s.lastDetail = truncateDetail(result);
+
+      if (s.agentSessionID !== undefined) {
+        void this.store.updateFleetEntry(s.agentSessionID, { result: s.result });
+      }
+    }
+
     this.onEvent('state', s);
     this.emitChange();
   }

package/src/daemon/start-headless-run.ts

@@ -6,6 +6,7 @@ import { isRecord } from '../shared/report';
 import type { SessionID } from '../shared/session-id';
 import { buildHeadlessEnv } from './build-headless-env';
 import { resolveHeadlessExecutable } from './resolve-headless-executable';
+import { truncateSummary } from './truncate-summary';
 
 const PERMISSION_MODES = [
   'default',
@@ -40,7 +41,7 @@ interface HeadlessRunHandle {
 /**
  * Runs one headless Agent SDK turn over a session, rendering its structured
  * messages as plain lines into the session's output pipe. The run ends in
- * done (with the result as the summary) or needs_you (errors, turn limits,
+ * done (with the turn's whole result) or needs_you (errors, turn limits,
  * anything a human must look at).
  */
 export function startHeadlessRun(
@@ -89,7 +90,7 @@ export function startHeadlessRun(
         }
 
         if (message.subtype === 'success') {
-          hooks.onDone(truncateSummary(message.result));
+          hooks.onDone(message.result);
           continue;
         }
 
@@ -170,9 +171,3 @@ export function renderSdkMessage(message: RenderableMessage): string | null {
 
   return null;
 }
-
-function truncateSummary(text: string): string {
-  const flat = text.replaceAll('\n', ' ');
-
-  return flat.length <= 200 ? flat : `${flat.slice(0, 199)}…`;
-}