sitedrift 0.1.0 → 0.2.0

package/src/agent.mjs

@@ -0,0 +1,73 @@
+import http from 'node:http';
+import https from 'node:https';
+import { readSession } from './session.mjs';
+
+function output(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+function routeFor(command) {
+  if (command.name === 'status' || command.name === 'context') return '/api/v1/session';
+  return '/api/v1/notes';
+}
+
+export async function requestSession(session, pathname, init = {}) {
+  const url = new URL(pathname, session.url);
+  const transport = url.protocol === 'https:' ? https : http;
+  const text = await new Promise((resolve, reject) => {
+    const req = transport.request(url, {
+      method: init.method || 'GET',
+      rejectUnauthorized: false,
+      headers: {
+        authorization: `Bearer ${session.token}`,
+        'content-type': 'application/json',
+        ...(init.headers || {}),
+      },
+    }, (res) => {
+      let data = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        if ((res.statusCode || 500) >= 400) {
+          try { reject(new Error(JSON.parse(data).error)); } catch { reject(new Error(data || `HTTP ${res.statusCode}`)); }
+        } else {
+          resolve(data);
+        }
+      });
+    });
+    req.on('error', reject);
+    if (init.body) req.write(init.body);
+    req.end();
+  });
+  return JSON.parse(text);
+}
+
+export async function runAgentCommand(command, config) {
+  const session = readSession(config.port);
+  if (command.name === 'status' || command.name === 'context' || command.action === 'list') {
+    output(await requestSession(session, routeFor(command)));
+    return 0;
+  }
+
+  const op = command.action === 'add'
+    ? {
+        op: 'add',
+        text: command.text,
+        author: command.author || config.author,
+        route: command.route || '/',
+        side: command.side || null,
+      }
+    : command.action === 'resolve'
+      ? { op: 'resolve', id: command.id }
+      : command.action === 'reopen'
+        ? { op: 'reopen', id: command.id }
+        : command.action === 'remove'
+          ? { op: 'remove', id: command.id }
+          : { op: 'clear' };
+
+  output(await requestSession(session, '/api/v1/notes', {
+    method: 'POST',
+    body: JSON.stringify(op),
+  }));
+  return 0;
+}

package/src/browser.mjs

@@ -0,0 +1,9 @@
+import { spawn } from 'node:child_process';
+
+export function openBrowser(url) {
+  const cmd = process.platform === 'darwin' ? 'open'
+    : process.platform === 'win32' ? 'start' : 'xdg-open';
+  try {
+    spawn(cmd, [url], { stdio: 'ignore', detached: true, shell: process.platform === 'win32' }).unref();
+  } catch {}
+}

package/src/cli.mjs

@@ -0,0 +1,215 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+// Short flags and the boolean flags that never consume the next argument.
+const ALIASES = { d: 'dev', l: 'live', p: 'port', o: 'open', h: 'help', v: 'version' };
+const BOOLEANS = new Set(['open', 'http', 'https', 'setup-https', 'help', 'version']);
+const VALUE_FLAGS = new Set([
+  'dev', 'live', 'port', 'host', 'cert', 'key', 'notes', 'brand', 'author',
+  'vault', 'config', 'route', 'side',
+]);
+const KNOWN_FLAGS = new Set([...BOOLEANS, ...VALUE_FLAGS]);
+const CONFIG_NAMES = ['sitedrift.config.json', '.sitedriftrc.json'];
+
+export function parseArgs(argv) {
+  const opts = {};
+  const positionals = [];
+  for (let i = 0; i < argv.length; i++) {
+    let arg = argv[i];
+    if (arg === '--') { positionals.push(...argv.slice(i + 1)); break; }
+    if (arg[0] !== '-' || arg === '-') { positionals.push(arg); continue; }
+    arg = arg.replace(/^--?/, '');
+    let value;
+    const eq = arg.indexOf('=');
+    if (eq !== -1) { value = arg.slice(eq + 1); arg = arg.slice(0, eq); }
+    const name = ALIASES[arg] || arg;
+    if (!KNOWN_FLAGS.has(name)) throw new Error(`Unknown option: --${arg}`);
+    if (BOOLEANS.has(name)) { opts[name] = true; continue; }
+    if (value === undefined) {
+      const next = argv[i + 1];
+      if (next !== undefined && next[0] !== '-') { value = next; i++; }
+      else throw new Error(`Option --${name} requires a value.`);
+    }
+    opts[name] = value;
+  }
+  return { opts, positionals };
+}
+
+function findConfigFile(start = process.cwd()) {
+  let dir = path.resolve(start);
+  while (true) {
+    for (const name of CONFIG_NAMES) {
+      const file = path.join(dir, name);
+      if (fs.existsSync(file)) return file;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+function readConfigFile(explicit) {
+  const file = explicit ? path.resolve(explicit) : findConfigFile();
+  if (!file) return {};
+  let value;
+  try {
+    value = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (error) {
+    throw new Error(`Could not read config ${file}: ${error.message}`);
+  }
+  if (!value || Array.isArray(value) || typeof value !== 'object') {
+    throw new Error(`Config ${file} must contain a JSON object.`);
+  }
+  const allowed = new Set(['dev', 'live', 'port', 'host', 'cert', 'key', 'notes', 'brand', 'author', 'vault', 'https', 'open']);
+  const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+  if (unknown.length) throw new Error(`Unknown config key${unknown.length === 1 ? '' : 's'}: ${unknown.join(', ')}`);
+  return value;
+}
+
+// SITEDRIFT_<NAME> is the public env var; SITE_COMPARE_<NAME> is the legacy name
+// kept so the `site compare` wrapper keeps working after extraction.
+function envVal(name) {
+  const v = process.env[`SITEDRIFT_${name}`] ?? process.env[`SITE_COMPARE_${name}`];
+  return v === undefined || v === '' ? undefined : v;
+}
+
+// Precedence for every setting: CLI flag > env > built-in default.
+function pick(opts, fileConfig, flag, name, fallback) {
+  return opts[flag] ?? envVal(name) ?? fileConfig[flag] ?? fallback;
+}
+
+function boolean(value, name) {
+  if (typeof value === 'boolean') return value;
+  if (value === undefined) return false;
+  if (value === '1' || value === 'true') return true;
+  if (value === '0' || value === 'false') return false;
+  throw new Error(`${name} must be true/false or 1/0.`);
+}
+
+export function cleanBase(value) {
+  const url = new URL(value);
+  url.pathname = url.pathname.replace(/\/+$/, '');
+  url.search = '';
+  url.hash = '';
+  return url;
+}
+
+export function readVersion() {
+  try {
+    return JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+  } catch { return '0.0.0'; }
+}
+
+export function printHelp() {
+  console.log(`sitedrift — frame local dev against production, side-by-side on the same route.
+
+Usage:
+  sitedrift [path] [options]
+  npx sitedrift /pricing --dev http://localhost:4321 --live https://example.com --open
+  sitedrift status
+  sitedrift context
+  sitedrift mcp
+  sitedrift notes list
+  sitedrift notes add <text> [--route /path] [--side dev|live] [--author name]
+  sitedrift notes resolve|reopen|remove <id>
+  sitedrift notes clear
+
+Options:
+  -d, --dev <url>     Left-pane (dev) origin            [default http://127.0.0.1:4321]
+  -l, --live <url>    Right-pane (live) origin          [default https://example.com]
+  -p, --port <n>      Listen port                       [default 4178]
+      --host <addr>   Bind address                      [default 127.0.0.1]
+  -o, --open          Open the viewer in your browser
+      --https         Serve HTTPS with an auto cert (mkcert if present, else openssl)
+      --setup-https   One-time: generate + trust a local cert, then exit
+      --http          Force plain HTTP (the default; overrides --https)
+      --cert <file>   TLS cert (serve HTTPS; needs --key)
+      --key <file>    TLS key
+      --notes <file>  Shared review-notes JSON          [default \$TMPDIR/sitedrift-notes.json]
+      --brand <text>  Strip "| <text>" from pane-header titles
+      --author <name> Byline for notes added in the viewer
+      --vault <dir>   Enable "Send to vault" (writes review markdown here)
+      --config <file> Read project configuration from a JSON file
+  -h, --help          Show this help
+  -v, --version       Print version
+
+Every option also reads SITEDRIFT_<NAME> (e.g. SITEDRIFT_DEV). Binds to
+127.0.0.1 by default — it strips framing/isolation headers, so never expose it
+publicly. See https://github.com/joeseverino/sitedrift`);
+}
+
+export function resolveConfig(argv = process.argv.slice(2)) {
+  const { opts, positionals } = parseArgs(argv);
+  if (positionals.length > 1) throw new Error(`Unexpected argument: ${positionals[1]}`);
+  const fileConfig = readConfigFile(opts.config);
+  const port = Number(pick(opts, fileConfig, 'port', 'PORT', 4178));
+  if (!Number.isInteger(port) || port < 1 || port > 65533) {
+    throw new Error('Port must be an integer from 1 to 65533 (the next two ports isolate DEV and LIVE).');
+  }
+  const certFile = opts.http ? undefined : pick(opts, fileConfig, 'cert', 'CERT', undefined);
+  const keyFile = opts.http ? undefined : pick(opts, fileConfig, 'key', 'KEY', undefined);
+  if (!!certFile !== !!keyFile) throw new Error('--cert and --key must be provided together.');
+  const host = pick(opts, fileConfig, 'host', 'HOST', '127.0.0.1');
+  if (!['127.0.0.1', 'localhost', '::1'].includes(host)) {
+    throw new Error('Host must be loopback (127.0.0.1, localhost, or ::1).');
+  }
+  return {
+    opts,
+    help: !!opts.help,
+    version: !!opts.version,
+    setupHttps: !!opts['setup-https'],
+    https: !opts.http && boolean(pick(opts, fileConfig, 'https', 'HTTPS', false), 'https'),
+    host,
+    port,
+    devBase: cleanBase(pick(opts, fileConfig, 'dev', 'DEV', 'http://127.0.0.1:4321')),
+    liveBase: cleanBase(pick(opts, fileConfig, 'live', 'LIVE', 'https://example.com')),
+    certFile,
+    keyFile,
+    notesFile: pick(opts, fileConfig, 'notes', 'NOTES', `${os.tmpdir()}/sitedrift-notes.json`),
+    brand: pick(opts, fileConfig, 'brand', 'BRAND', ''),
+    author: pick(opts, fileConfig, 'author', 'AUTHOR', 'you'),
+    vaultDir: pick(opts, fileConfig, 'vault', 'VAULT', ''),
+    open: boolean(pick(opts, fileConfig, 'open', 'OPEN', false), 'open'),
+    initialPath: positionals[0]
+      ? '/' + String(positionals[0]).replace(/^\/+/, '')
+      : '',
+  };
+}
+
+export function parseCommand(argv = process.argv.slice(2)) {
+  const name = argv[0];
+  if (name !== 'status' && name !== 'context' && name !== 'notes' && name !== 'mcp') return null;
+  if (name === 'mcp') {
+    if (argv.length > 1) throw new Error('Usage: sitedrift mcp');
+    return { command: { name }, argv: [] };
+  }
+  if (name === 'status' || name === 'context') {
+    return { command: { name }, argv: argv.slice(1) };
+  }
+  const action = argv[1];
+  if (!['list', 'add', 'resolve', 'reopen', 'remove', 'clear'].includes(action)) {
+    throw new Error('Usage: sitedrift notes list|add|resolve|reopen|remove|clear');
+  }
+  const tail = argv.slice(2);
+  let subject;
+  if (action === 'add' || ['resolve', 'reopen', 'remove'].includes(action)) {
+    subject = tail.shift();
+    if (!subject) throw new Error(`sitedrift notes ${action} requires ${action === 'add' ? 'text' : 'an id'}.`);
+  }
+  const { opts, positionals } = parseArgs(tail);
+  if (positionals.length) throw new Error(`Unexpected argument: ${positionals[0]}`);
+  if (opts.side && !['dev', 'live'].includes(opts.side)) throw new Error('--side must be dev or live.');
+  return {
+    command: {
+      name,
+      action,
+      text: action === 'add' ? subject : undefined,
+      id: action === 'add' ? undefined : subject,
+      route: opts.route,
+      side: opts.side,
+      author: opts.author,
+    },
+    argv: tail,
+  };
+}

package/src/http.mjs

@@ -0,0 +1,21 @@
+// Small shared HTTP helpers used by the request handler and proxy.
+
+export function send(res, status, body, type = 'text/plain; charset=utf-8') {
+  res.writeHead(status, {
+    'Content-Type': type,
+    'Cache-Control': 'no-store',
+  });
+  res.end(body);
+}
+
+export function readBody(req) {
+  return new Promise((resolve) => {
+    let data = '';
+    req.on('data', (chunk) => {
+      data += chunk;
+      if (data.length > 1e6) req.destroy();
+    });
+    req.on('end', () => resolve(data));
+    req.on('error', () => resolve(data));
+  });
+}

package/src/mcp.mjs

@@ -0,0 +1,324 @@
+import { readVersion } from './cli.mjs';
+import { requestSession } from './agent.mjs';
+import { readSession } from './session.mjs';
+
+const PROTOCOL_VERSIONS = new Set([
+  '2024-11-05',
+  '2025-03-26',
+  '2025-06-18',
+  '2025-11-25',
+]);
+const LATEST_PROTOCOL_VERSION = '2025-11-25';
+
+const TOOLS = [
+  {
+    name: 'sitedrift_context',
+    title: 'Get sitedrift session context',
+    description: 'Get the active DEV/LIVE targets, viewer URL, capabilities, and session metadata. Call this first.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        port: { type: 'integer', minimum: 1, maximum: 65533, default: 4178 },
+      },
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: true, openWorldHint: false },
+  },
+  {
+    name: 'sitedrift_notes_list',
+    title: 'List review notes',
+    description: 'List the current shared visual-review notes.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        port: { type: 'integer', minimum: 1, maximum: 65533, default: 4178 },
+      },
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: true, openWorldHint: false },
+  },
+  {
+    name: 'sitedrift_note_add',
+    title: 'Add a review note',
+    description: 'Add one concrete visual finding for the user or another agent.',
+    inputSchema: {
+      type: 'object',
+      required: ['text'],
+      properties: {
+        text: { type: 'string', minLength: 1, maxLength: 2000 },
+        route: { type: 'string', default: '/' },
+        side: { type: ['string', 'null'], enum: ['dev', 'live', null] },
+        author: { type: 'string', default: 'agent' },
+        port: { type: 'integer', minimum: 1, maximum: 65533, default: 4178 },
+      },
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+  },
+  ...['resolve', 'reopen', 'remove'].map((action) => ({
+    name: `sitedrift_note_${action}`,
+    title: `${action[0].toUpperCase()}${action.slice(1)} a review note`,
+    description: `${action[0].toUpperCase()}${action.slice(1)} one shared review note by ID.`,
+    inputSchema: {
+      type: 'object',
+      required: ['id'],
+      properties: {
+        id: { type: 'string', minLength: 1 },
+        port: { type: 'integer', minimum: 1, maximum: 65533, default: 4178 },
+      },
+      additionalProperties: false,
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: action === 'remove',
+      idempotentHint: action !== 'remove',
+      openWorldHint: false,
+    },
+  })),
+  {
+    name: 'sitedrift_notes_clear',
+    title: 'Clear all review notes',
+    description: 'Delete every note in the active review session. Use only when the user explicitly requests it.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        port: { type: 'integer', minimum: 1, maximum: 65533, default: 4178 },
+      },
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+  },
+  {
+    name: 'sitedrift_setup',
+    title: 'Get setup instructions',
+    description: 'Return the shortest install, project configuration, launch, HTTPS, and MCP-client setup instructions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        dev: { type: 'string', description: 'Local development origin.' },
+        live: { type: 'string', description: 'Production origin.' },
+      },
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: true, openWorldHint: false },
+  },
+];
+
+function jsonResult(value) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+    structuredContent: value,
+  };
+}
+
+function setupInstructions(args = {}) {
+  const dev = args.dev || 'http://localhost:4321';
+  const live = args.live || 'https://example.com';
+  return {
+    install: 'npm install --global sitedrift',
+    configFile: 'sitedrift.config.json',
+    config: { dev, live, open: true },
+    launch: 'sitedrift',
+    https: ['sitedrift --setup-https', 'sitedrift --https'],
+    mcp: {
+      command: 'sitedrift-mcp',
+      alternative: 'npx -y sitedrift mcp',
+      config: { command: 'sitedrift-mcp', args: [] },
+    },
+    firstTool: 'sitedrift_context',
+    guide: 'Read the packaged AGENTS.md or the sitedrift://guide MCP resource.',
+  };
+}
+
+function noteOperation(name, args) {
+  if (name === 'sitedrift_note_add') {
+    return {
+      op: 'add',
+      text: args.text,
+      route: args.route || '/',
+      side: args.side || null,
+      author: args.author || 'agent',
+    };
+  }
+  if (name === 'sitedrift_notes_clear') return { op: 'clear' };
+  return { op: name.replace('sitedrift_note_', ''), id: args.id };
+}
+
+async function callTool(name, args = {}) {
+  if (name === 'sitedrift_setup') return setupInstructions(args);
+  const session = readSession(args.port || 4178);
+  if (name === 'sitedrift_context') return requestSession(session, '/api/v1/session');
+  if (name === 'sitedrift_notes_list') return requestSession(session, '/api/v1/notes');
+  if (!TOOLS.some((tool) => tool.name === name)) throw new Error(`Unknown tool: ${name}`);
+  return requestSession(session, '/api/v1/notes', {
+    method: 'POST',
+    body: JSON.stringify(noteOperation(name, args)),
+  });
+}
+
+function guideText() {
+  return `# sitedrift agent workflow
+
+1. Call sitedrift_context before doing review work.
+2. Use the returned viewer URL and DEV/LIVE targets as the source of truth.
+3. Record one concrete issue per sitedrift_note_add call. Include the route and side.
+4. Re-list notes before changing code and after verification.
+5. Resolve a note only after verifying the fix; remove notes only when explicitly asked.
+6. If no session is running, call sitedrift_setup and help the user create sitedrift.config.json, then launch sitedrift.
+
+The MCP server never receives browser credentials and only talks to a loopback sitedrift session using its private mode-0600 descriptor.`;
+}
+
+function promptResult(args = {}) {
+  const route = args.route || '/';
+  return {
+    description: 'Review one route with sitedrift and leave actionable shared notes.',
+    messages: [{
+      role: 'user',
+      content: {
+        type: 'text',
+        text: `Review ${route} with sitedrift. Call sitedrift_context first, inspect DEV and LIVE, add one specific note per discrepancy, avoid duplicates, and resolve notes only after verification.`,
+      },
+    }],
+  };
+}
+
+export async function handleMcpRequest(message) {
+  const { id, method, params = {} } = message;
+  if (method === 'notifications/initialized' || method === 'notifications/cancelled') return null;
+  if (method === 'ping') return { jsonrpc: '2.0', id, result: {} };
+  if (method === 'initialize') {
+    const requested = params.protocolVersion;
+    if (requested && !PROTOCOL_VERSIONS.has(requested)) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        error: {
+          code: -32602,
+          message: 'Unsupported protocol version',
+          data: { supported: [...PROTOCOL_VERSIONS], requested },
+        },
+      };
+    }
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: requested || LATEST_PROTOCOL_VERSION,
+        capabilities: { tools: {}, resources: {}, prompts: {} },
+        serverInfo: { name: 'sitedrift', version: readVersion() },
+        instructions: 'Call sitedrift_context first. If no session is running, call sitedrift_setup.',
+      },
+    };
+  }
+  if (method === 'tools/list') return { jsonrpc: '2.0', id, result: { tools: TOOLS } };
+  if (method === 'tools/call') {
+    try {
+      return { jsonrpc: '2.0', id, result: jsonResult(await callTool(params.name, params.arguments)) };
+    } catch (error) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          content: [{ type: 'text', text: error.message }],
+          isError: true,
+        },
+      };
+    }
+  }
+  if (method === 'resources/list') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        resources: [
+          { uri: 'sitedrift://guide', name: 'Agent guide', mimeType: 'text/markdown' },
+          { uri: 'sitedrift://session', name: 'Active session', mimeType: 'application/json' },
+          { uri: 'sitedrift://notes', name: 'Review notes', mimeType: 'application/json' },
+        ],
+      },
+    };
+  }
+  if (method === 'resources/read') {
+    try {
+      let text;
+      let mimeType = 'application/json';
+      if (params.uri === 'sitedrift://guide') {
+        text = guideText();
+        mimeType = 'text/markdown';
+      } else {
+        const session = readSession(4178);
+        const pathname = params.uri === 'sitedrift://session'
+          ? '/api/v1/session'
+          : params.uri === 'sitedrift://notes'
+            ? '/api/v1/notes'
+            : null;
+        if (!pathname) throw new Error(`Unknown resource: ${params.uri}`);
+        text = JSON.stringify(await requestSession(session, pathname), null, 2);
+      }
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: { contents: [{ uri: params.uri, mimeType, text }] },
+      };
+    } catch (error) {
+      return { jsonrpc: '2.0', id, error: { code: -32002, message: error.message } };
+    }
+  }
+  if (method === 'prompts/list') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        prompts: [{
+          name: 'review_route',
+          title: 'Review a route',
+          description: 'Compare one route and record actionable findings.',
+          arguments: [{ name: 'route', description: 'Route to review, such as /pricing.', required: false }],
+        }],
+      },
+    };
+  }
+  if (method === 'prompts/get') {
+    if (params.name !== 'review_route') {
+      return { jsonrpc: '2.0', id, error: { code: -32602, message: `Unknown prompt: ${params.name}` } };
+    }
+    return { jsonrpc: '2.0', id, result: promptResult(params.arguments) };
+  }
+  return { jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${method}` } };
+}
+
+async function processMessage(message) {
+  if (Array.isArray(message)) {
+    const responses = (await Promise.all(message.map(handleMcpRequest))).filter(Boolean);
+    return responses.length ? responses : null;
+  }
+  return handleMcpRequest(message);
+}
+
+export function runMcpServer(input = process.stdin, output = process.stdout) {
+  let buffer = '';
+  input.setEncoding('utf8');
+  input.on('data', (chunk) => {
+    buffer += chunk;
+    let newline;
+    while ((newline = buffer.indexOf('\n')) !== -1) {
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      if (!line) continue;
+      Promise.resolve()
+        .then(() => JSON.parse(line))
+        .then(processMessage)
+        .then((response) => {
+          if (response) output.write(`${JSON.stringify(response)}\n`);
+        })
+        .catch((error) => {
+          output.write(`${JSON.stringify({
+            jsonrpc: '2.0',
+            id: null,
+            error: { code: -32700, message: error.message },
+          })}\n`);
+        });
+    }
+  });
+}