@stage-labs/metro 0.1.0-beta.7 → 0.1.0-beta.71

package/runtime/node_modules/@metro-labs/mcp/src/daemon/claude-files.ts

@@ -0,0 +1,329 @@
+import {
+  closeSync,
+  createReadStream,
+  existsSync,
+  openSync,
+  readdirSync,
+  readSync,
+  rmSync,
+  statSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { ApiError } from './api-error.js';
+import { isRecord } from './is-record.js';
+
+const PROJECT_RE = /^[A-Za-z0-9._-]{1,200}$/;
+const SESSION_RE = /^[A-Za-z0-9][A-Za-z0-9-]{7,63}$/;
+const MEMORY_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,119}\.md$/;
+const EDGE_BYTES = 64 * 1024;
+const TEXT_CAP = 20_000;
+const RESULT_CAP = 8_000;
+const INPUT_CAP = 4_000;
+const FILE_CAP = 1_000_000;
+const NOISE = ['<task-notification>', '<system-reminder>', '<local-command', '<command-name>'];
+
+export function claudeDir(): string {
+  const explicit = process.env.METRO_CLAUDE_DIR?.trim();
+  if (explicit !== undefined && explicit !== '') return explicit;
+  const cfg = process.env.CLAUDE_CONFIG_DIR?.trim();
+  if (cfg !== undefined && cfg !== '') return cfg;
+  return join(homedir(), '.claude');
+}
+
+const str = (v: unknown): string | null => (typeof v === 'string' && v !== '' ? v : null);
+
+function safeName(value: string, re: RegExp, what: string): string {
+  if (!re.test(value) || value === '.' || value === '..')
+    throw new ApiError(`that is not a ${what}`, 400);
+  return value;
+}
+
+function projectDir(project: string, dir: string): string {
+  const path = join(dir, 'projects', safeName(project, PROJECT_RE, 'Claude project id'));
+  if (!existsSync(path)) throw new ApiError('no such Claude project', 404);
+  return path;
+}
+
+function parseLines(text: string): Record<string, unknown>[] {
+  const out: Record<string, unknown>[] = [];
+  for (const line of text.split('\n')) {
+    if (line.trim() === '') continue;
+    try {
+      const parsed: unknown = JSON.parse(line);
+      if (isRecord(parsed)) out.push(parsed);
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+
+function readEdge(path: string, fromEnd: boolean): Record<string, unknown>[] {
+  const size = statSync(path).size;
+  const length = Math.min(EDGE_BYTES, size);
+  const fd = openSync(path, 'r');
+  try {
+    const buffer = Buffer.alloc(length);
+    readSync(fd, buffer, 0, length, fromEnd ? size - length : 0);
+    const text = buffer.toString('utf8');
+    const cut = fromEnd && length < size ? text.indexOf('\n') + 1 : 0;
+    return parseLines(text.slice(cut));
+  } finally {
+    closeSync(fd);
+  }
+}
+
+export interface ClaudeProject {
+  id: string;
+  cwd: string | null;
+  sessions: number;
+  lastActiveAt: string | null;
+  hasMemory: boolean;
+}
+
+function sessionFiles(path: string): { name: string; mtime: number; size: number }[] {
+  return readdirSync(path)
+    .filter((name) => name.endsWith('.jsonl'))
+    .map((name) => {
+      const s = statSync(join(path, name));
+      return { name, mtime: s.mtimeMs, size: s.size };
+    })
+    .sort((a, b) => b.mtime - a.mtime);
+}
+
+function cwdOf(path: string): string | null {
+  for (const line of readEdge(path, false)) {
+    const cwd = str(line.cwd);
+    if (cwd !== null) return cwd;
+  }
+  return null;
+}
+
+export function listClaudeProjects(dir = claudeDir()): ClaudeProject[] {
+  const root = join(dir, 'projects');
+  if (!existsSync(root)) return [];
+  return readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && PROJECT_RE.test(entry.name))
+    .map((entry) => {
+      const path = join(root, entry.name);
+      const files = sessionFiles(path);
+      const newest = files[0];
+      return {
+        id: entry.name,
+        cwd: newest === undefined ? null : cwdOf(join(path, newest.name)),
+        sessions: files.length,
+        lastActiveAt: newest === undefined ? null : new Date(newest.mtime).toISOString(),
+        hasMemory: existsSync(join(path, 'memory')),
+      };
+    })
+    .sort((a, b) => (b.lastActiveAt ?? '').localeCompare(a.lastActiveAt ?? ''));
+}
+
+export interface ClaudeSession {
+  id: string;
+  title: string;
+  startedAt: string | null;
+  lastAt: string;
+  bytes: number;
+  gitBranch: string | null;
+  version: string | null;
+}
+
+function firstPrompt(lines: Record<string, unknown>[]): string | null {
+  for (const line of lines) {
+    if (line.type !== 'user' || line.isSidechain === true) continue;
+    const message = isRecord(line.message) ? line.message : {};
+    const text = promptText(message.content);
+    if (text !== null && !NOISE.some((n) => text.startsWith(n))) return text.slice(0, 120);
+  }
+  return null;
+}
+
+function promptText(content: unknown): string | null {
+  if (typeof content === 'string') return content.trim() === '' ? null : content.trim();
+  if (!Array.isArray(content)) return null;
+  for (const block of content)
+    if (isRecord(block) && block.type === 'text') {
+      const text = str(block.text);
+      if (text !== null) return text.trim();
+    }
+  return null;
+}
+
+function sessionOf(path: string, id: string, mtime: number, size: number): ClaudeSession {
+  const head = readEdge(path, false);
+  const tail = readEdge(path, true);
+  const titled = [...tail].reverse().find((l) => l.type === 'ai-title' && str(l.aiTitle) !== null);
+  const meta = head.find((l) => l.type === 'user' || l.type === 'assistant') ?? {};
+  return {
+    id,
+    title: (titled === undefined ? null : str(titled.aiTitle)) ?? firstPrompt(head) ?? 'Untitled session',
+    startedAt: str(head.find((l) => str(l.timestamp) !== null)?.timestamp) ?? null,
+    lastAt: new Date(mtime).toISOString(),
+    bytes: size,
+    gitBranch: str(meta.gitBranch),
+    version: str(meta.version),
+  };
+}
+
+export function listClaudeSessions(project: string, dir = claudeDir()): ClaudeSession[] {
+  const path = projectDir(project, dir);
+  return sessionFiles(path).map((f) =>
+    sessionOf(join(path, f.name), f.name.slice(0, -'.jsonl'.length), f.mtime, f.size),
+  );
+}
+
+export type Block =
+  | { kind: 'text'; text: string }
+  | { kind: 'tool_use'; name: string; input: string }
+  | { kind: 'tool_result'; text: string; isError: boolean }
+  | { kind: 'thinking' }
+  | { kind: 'image' };
+
+export interface TranscriptEntry {
+  uuid: string;
+  at: string | null;
+  role: 'user' | 'assistant';
+  blocks: Block[];
+}
+
+export interface TranscriptPage {
+  entries: TranscriptEntry[];
+  total: number;
+  next: number | null;
+}
+
+const cap = (text: string, max: number): string =>
+  text.length > max ? `${text.slice(0, max)}\n… (${String(text.length - max)} more characters)` : text;
+
+function resultText(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((b) => (isRecord(b) && b.type === 'text' ? (str(b.text) ?? '') : ''))
+    .filter((t) => t !== '')
+    .join('\n');
+}
+
+function textBlock(raw: Record<string, unknown>): Block | null {
+  const text = str(raw.text);
+  if (text === null || NOISE.some((n) => text.startsWith(n))) return null;
+  return { kind: 'text', text: cap(text, TEXT_CAP) };
+}
+
+const BLOCKS: Record<string, (raw: Record<string, unknown>) => Block | null> = {
+  text: textBlock,
+  tool_use: (raw) => ({
+    kind: 'tool_use',
+    name: str(raw.name) ?? 'tool',
+    input: cap(JSON.stringify(raw.input ?? {}, null, 1), INPUT_CAP),
+  }),
+  tool_result: (raw) => ({
+    kind: 'tool_result',
+    text: cap(resultText(raw.content), RESULT_CAP),
+    isError: raw.is_error === true,
+  }),
+  thinking: () => ({ kind: 'thinking' }),
+  image: () => ({ kind: 'image' }),
+};
+
+function blockOf(raw: unknown): Block | null {
+  if (!isRecord(raw) || typeof raw.type !== 'string') return null;
+  const make = BLOCKS[raw.type];
+  return make === undefined ? null : make(raw);
+}
+
+function entryOf(line: Record<string, unknown>): TranscriptEntry | null {
+  if ((line.type !== 'user' && line.type !== 'assistant') || line.isSidechain === true) return null;
+  const message = isRecord(line.message) ? line.message : {};
+  const content = message.content;
+  const blocks =
+    typeof content === 'string'
+      ? [blockOf({ type: 'text', text: content })]
+      : Array.isArray(content)
+        ? content.map(blockOf)
+        : [];
+  const kept = blocks.filter((b): b is Block => b !== null);
+  if (kept.length === 0) return null;
+  return { uuid: str(line.uuid) ?? '', at: str(line.timestamp), role: line.type, blocks: kept };
+}
+
+export async function readTranscript(
+  project: string,
+  session: string,
+  offset: number,
+  limit: number,
+  dir = claudeDir(),
+): Promise<TranscriptPage> {
+  const path = join(projectDir(project, dir), `${safeName(session, SESSION_RE, 'session id')}.jsonl`);
+  if (!existsSync(path)) throw new ApiError('no such session', 404);
+  const entries: TranscriptEntry[] = [];
+  let total = 0;
+  const lines = createInterface({ input: createReadStream(path, { encoding: 'utf8' }), crlfDelay: Infinity });
+  for await (const line of lines) {
+    const parsed = parseLines(line)[0];
+    const entry = parsed === undefined ? null : entryOf(parsed);
+    if (entry === null) continue;
+    if (total >= offset && entries.length < limit) entries.push(entry);
+    total += 1;
+  }
+  return { entries, total, next: offset + limit < total ? offset + limit : null };
+}
+
+export function deleteClaudeSession(project: string, session: string, dir = claudeDir()): void {
+  const root = projectDir(project, dir);
+  const id = safeName(session, SESSION_RE, 'session id');
+  const file = join(root, `${id}.jsonl`);
+  if (!existsSync(file)) throw new ApiError('no such session', 404);
+  rmSync(file);
+  rmSync(join(root, id), { recursive: true, force: true });
+}
+
+export interface MemoryFile {
+  name: string;
+  bytes: number;
+  modifiedAt: string;
+}
+
+export interface MemoryListing {
+  files: MemoryFile[];
+  index: string | null;
+}
+
+function memoryDir(project: string, dir: string): string {
+  return join(projectDir(project, dir), 'memory');
+}
+
+function readCapped(path: string): string {
+  const size = statSync(path).size;
+  const fd = openSync(path, 'r');
+  try {
+    const buffer = Buffer.alloc(Math.min(size, FILE_CAP));
+    readSync(fd, buffer, 0, buffer.length, 0);
+    return size > FILE_CAP ? `${buffer.toString('utf8')}\n\n… truncated` : buffer.toString('utf8');
+  } finally {
+    closeSync(fd);
+  }
+}
+
+export function listMemory(project: string, dir = claudeDir()): MemoryListing {
+  const path = memoryDir(project, dir);
+  if (!existsSync(path)) return { files: [], index: null };
+  const files = readdirSync(path)
+    .filter((name) => MEMORY_RE.test(name) && name !== 'MEMORY.md')
+    .map((name) => {
+      const s = statSync(join(path, name));
+      return { name, bytes: s.size, modifiedAt: s.mtime.toISOString() };
+    })
+    .sort((a, b) => a.name.localeCompare(b.name));
+  const index = join(path, 'MEMORY.md');
+  return { files, index: existsSync(index) ? readCapped(index) : null };
+}
+
+export function readMemoryFile(project: string, name: string, dir = claudeDir()): string {
+  const path = join(memoryDir(project, dir), safeName(name, MEMORY_RE, 'memory file name'));
+  if (!existsSync(path)) throw new ApiError('no such memory file', 404);
+  return readCapped(path);
+}

package/runtime/node_modules/@metro-labs/mcp/src/daemon/connect-hint.ts

@@ -0,0 +1,39 @@
+import { hostname } from 'node:os';
+
+const uiBase = (): string => process.env.METRO_UI_URL ?? 'https://metro.box';
+
+const connectLink = (base: string): string =>
+  `${uiBase()}/#/${new URL(base).host}`;
+
+const ownerLine = (owner: string | null): string =>
+  owner === null
+    ? 'No owner is set, so no wallet can sign in. Restart with:  metro serve --owner <address>'
+    : `Only ${owner} can sign in.`;
+
+export function localConnectHint(port: number, owner: string | null): string {
+  const here = `http://127.0.0.1:${String(port)}`;
+  const forward = `ssh -L ${String(port)}:127.0.0.1:${String(port)} ${hostname()}`;
+  return [
+    'Manage this machine from the web UI:',
+    '',
+    `  ${connectLink(here)}`,
+    '',
+    `From another computer, forward the port first:  ${forward}`,
+    ownerLine(owner),
+    '',
+  ].join('\n');
+}
+
+export function publicConnectHint(url: string, owner: string | null): string {
+  return [
+    'Manage this machine from the web UI, from anywhere:',
+    '',
+    `  ${connectLink(url)}`,
+    '',
+    ownerLine(owner),
+    '',
+  ].join('\n');
+}
+
+export const tunnelPendingHint = (): string =>
+  'Publishing this daemon through Tailscale Funnel… (if Tailscale asks to enable Funnel, its link is in the log)\n';

package/runtime/node_modules/@metro-labs/mcp/src/daemon/connector-api.ts

@@ -0,0 +1,307 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import {
+  apiFailure,
+  apiSession,
+  projectParam,
+  bodyField,
+  cors,
+  readJsonBody,
+  sendJson,
+  type ApiSession,
+} from './api-http.js';
+import { parseId } from '../db/ids.js';
+import {
+  handleCallback,
+  handleConnect,
+  hostOf,
+  startOAuth,
+  type OAuthRouteDeps,
+} from './connector-oauth-routes.js';
+import { ConnectorUnauthorized } from './connector-verify.js';
+import type {
+  Connector,
+  ConnectorCheck,
+  ConnectorInput,
+  DeletedConnector,
+} from '../db/connectors.js';
+
+const PREFIX = '/api/connectors';
+
+const asText = (value: unknown): string =>
+  typeof value === 'string' ? value : '';
+
+export interface ConnectorApiDeps extends OAuthRouteDeps {
+  listConnectors: (subject: string, project: string) => Promise<Connector[]>;
+  createConnector: (
+    subject: string,
+    project: string,
+    input: ConnectorInput,
+  ) => Promise<Connector>;
+  verifyConnector: (subject: string, id: string) => Promise<ConnectorCheck>;
+  disconnectConnector: (subject: string, id: string) => Promise<Connector>;
+  renameConnector: (
+    subject: string,
+    id: string,
+    name: string,
+  ) => Promise<Connector>;
+  deleteConnector: (subject: string, id: string) => Promise<DeletedConnector>;
+}
+
+type Routable =
+  | { kind: 'collection' }
+  | { kind: 'callback' }
+  | { kind: 'connector'; id: string }
+  | { kind: 'verify'; id: string }
+  | { kind: 'connect'; id: string }
+  | { kind: 'disconnect'; id: string }
+  | { kind: 'rename'; id: string };
+
+type Target = Routable | { kind: 'unknown' } | null;
+
+function subTarget(id: string, rest: string[]): Target {
+  if (rest.length === 0) return { kind: 'connector', id };
+  if (rest.length > 1) return { kind: 'unknown' };
+  const head = rest[0];
+  if (head === 'verify') return { kind: 'verify', id };
+  if (head === 'connect') return { kind: 'connect', id };
+  if (head === 'disconnect') return { kind: 'disconnect', id };
+  if (head === 'rename') return { kind: 'rename', id };
+  return { kind: 'unknown' };
+}
+
+function target(path: string): Target {
+  if (path === PREFIX || path === `${PREFIX}/`) return { kind: 'collection' };
+  if (!path.startsWith(`${PREFIX}/`)) return null;
+  const segments = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
+  const head = segments[0];
+  if (head === undefined) return { kind: 'collection' };
+  if (head === 'callback' && segments.length === 1) return { kind: 'callback' };
+  const id = parseId(head);
+  return id === null ? { kind: 'unknown' } : subTarget(id, segments.slice(1));
+}
+
+function connectorPayload(
+  row: Connector,
+  detail = false,
+): Record<string, unknown> {
+  const { catalog, ...summary } = row.verified;
+  return {
+    id: row.id,
+    name: row.name,
+    url: row.url,
+    transport: row.transport,
+    auth: row.auth,
+    header: row.header,
+    signIn: row.signIn,
+    verified: detail ? { ...summary, catalog } : summary,
+  };
+}
+
+async function handleList(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+  session: ApiSession,
+): Promise<void> {
+  const project = projectParam(req);
+  if (project === null) {
+    sendJson(req, res, 400, { error: 'a project is required' });
+    return;
+  }
+  const rows = await deps.listConnectors(session.subject, project);
+  sendJson(req, res, 200, {
+    connectors: rows.map((row) => connectorPayload(row)),
+  });
+}
+
+async function handleCreate(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+  session: ApiSession,
+): Promise<void> {
+  const body = await readJsonBody(req);
+  const project = projectParam(req);
+  if (project === null) {
+    sendJson(req, res, 400, { error: 'a project is required' });
+    return;
+  }
+  const offered = asText(bodyField(body, 'value')).trim() !== '';
+  try {
+    const created = await deps.createConnector(session.subject, project, {
+      name: bodyField(body, 'name'),
+      url: bodyField(body, 'url'),
+      header: bodyField(body, 'header'),
+      value: bodyField(body, 'value'),
+    });
+    log.info(
+      { id: created.id, name: created.name, host: hostOf(created.url) },
+      'connector-api: created connector',
+    );
+    sendJson(req, res, 201, connectorPayload(created));
+  } catch (err) {
+    if (offered || !(err instanceof ConnectorUnauthorized)) throw err;
+    await startOAuth(req, res, deps, session, project, body, (row) =>
+      connectorPayload(row),
+    );
+  }
+}
+
+async function handleVerify(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+  session: ApiSession,
+  id: string,
+): Promise<void> {
+  const check = await deps.verifyConnector(session.subject, id);
+  log.info(
+    { id: check.id, name: check.name, ok: check.ok },
+    'connector-api: re-verified connector',
+  );
+  sendJson(req, res, 200, check);
+}
+
+async function handleDisconnect(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+  session: ApiSession,
+  id: string,
+): Promise<void> {
+  const row = await deps.disconnectConnector(session.subject, id);
+  log.info(
+    { id: row.id, name: row.name },
+    'connector-api: signed the connector out',
+  );
+  sendJson(req, res, 200, connectorPayload(row));
+}
+
+async function handleDelete(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+  session: ApiSession,
+  id: string,
+): Promise<void> {
+  const gone = await deps.deleteConnector(session.subject, id);
+  log.info(
+    { id: gone.id, name: gone.name },
+    'connector-api: deleted connector',
+  );
+  sendJson(req, res, 200, { id: gone.id, name: gone.name, deleted: true });
+}
+
+async function handleConnector(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+  session: ApiSession,
+  id: string,
+): Promise<void> {
+  if (req.method !== 'GET') {
+    await handleDelete(req, res, deps, session, id);
+    return;
+  }
+  const row = await deps.getConnector(session.subject, id);
+  sendJson(req, res, 200, connectorPayload(row, true));
+}
+
+async function handleRename(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+  session: ApiSession,
+  id: string,
+): Promise<void> {
+  const name = bodyField(await readJsonBody(req), 'name');
+  if (typeof name !== 'string') {
+    sendJson(req, res, 400, { error: 'name is required' });
+    return;
+  }
+  const row = await deps.renameConnector(session.subject, id, name);
+  log.info({ id: row.id, name: row.name }, 'connector-api: renamed connector');
+  sendJson(req, res, 200, connectorPayload(row));
+}
+
+async function route(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+  session: ApiSession,
+  tgt: Routable,
+): Promise<void> {
+  try {
+    if (tgt.kind === 'callback') return;
+    if (tgt.kind === 'verify')
+      await handleVerify(req, res, deps, session, tgt.id);
+    else if (tgt.kind === 'connect')
+      await handleConnect(req, res, deps, session, tgt.id);
+    else if (tgt.kind === 'disconnect')
+      await handleDisconnect(req, res, deps, session, tgt.id);
+    else if (tgt.kind === 'rename')
+      await handleRename(req, res, deps, session, tgt.id);
+    else if (tgt.kind === 'connector')
+      await handleConnector(req, res, deps, session, tgt.id);
+    else if (req.method === 'GET') await handleList(req, res, deps, session);
+    else await handleCreate(req, res, deps, session);
+  } catch (err) {
+    apiFailure(req, res, err, 'connector-api');
+  }
+}
+
+const ALLOWED: Record<Routable['kind'], string[]> = {
+  collection: ['GET', 'POST'],
+  callback: ['GET'],
+  connector: ['GET', 'DELETE'],
+  verify: ['POST'],
+  connect: ['POST'],
+  disconnect: ['POST'],
+  rename: ['POST'],
+};
+
+async function dispatch(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+  tgt: Routable,
+): Promise<void> {
+  if (tgt.kind === 'callback') {
+    handleCallback(req, res, deps);
+    return;
+  }
+  const session = await apiSession(req);
+  if (!session) {
+    sendJson(req, res, 401, { error: 'unauthorized' });
+    return;
+  }
+  await route(req, res, deps, session, tgt);
+}
+
+export function handleConnectorApiRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+): boolean {
+  const tgt = target((req.url ?? '').split('?')[0] ?? '');
+  if (tgt === null) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (tgt.kind === 'unknown') {
+    sendJson(req, res, 404, { error: 'no such connector' });
+    return true;
+  }
+  if (!ALLOWED[tgt.kind].includes(req.method ?? '')) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  dispatch(req, res, deps, tgt).catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'connector-api: unhandled error');
+    if (!res.headersSent)
+      sendJson(req, res, 500, { error: 'connector api failed' });
+  });
+  return true;
+}

package/runtime/node_modules/@metro-labs/mcp/src/daemon/connector-json.ts

@@ -0,0 +1,21 @@
+export interface RelayServerEntry {
+  id: string;
+  name: string;
+}
+
+export const NAME_PREFIX = 'metro.box ';
+
+export function relayServersJson(
+  entries: RelayServerEntry[],
+  base: string,
+  cliToken: string,
+): string {
+  const mcpServers: Record<string, unknown> = {};
+  for (const entry of entries)
+    mcpServers[`${NAME_PREFIX}${entry.name}`] = {
+      type: 'http',
+      url: `${base}/relay/${entry.id}`,
+      headers: { Authorization: `Bearer ${cliToken}` },
+    };
+  return JSON.stringify({ mcpServers }, null, 2);
+}