@operstack/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OperStack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+# @operstack/mcp
+
+Let Claude, Cursor or any MCP client measure a site the way a search engine and an AI actually read it.
+
+Ask your assistant *"why does ChatGPT recommend my competitor and not me?"* and it can now go and look: read the site, score six areas, follow the map the site offers to machines, and tell you what is actually missing. Free public signals only. No account, no API key, nothing stored.
+
+## Install
+
+In Claude Desktop, add this to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "operstack": {
+      "command": "npx",
+      "args": ["-y", "@operstack/mcp"]
+    }
+  }
+}
+```
+
+In Cursor, add the same block to `.cursor/mcp.json` in your project, or to `~/.cursor/mcp.json` for every project.
+
+Node 20 or newer. Nothing else to install.
+
+## What it can do
+
+**`audit_site`** reads a public site and scores six areas out of ten: technical SEO, content and structure, AEO (whether an answer engine can quote it), GEO (whether AI systems can identify and use it), off-page trust, and conversion. Returns every failing and borderline check with what was actually found on the pages, so the assistant can explain rather than guess.
+
+**`check_llms_txt`** reads the site's `/llms.txt`, checks it against the format, and follows its links to see whether each one still leads to a page, a redirect or nothing. This file rots silently, because no human ever opens it.
+
+**`compare_sites`** runs the same measurement on two to four sites and returns them side by side. Useful when the question is not *"am I bad"* but *"am I worse than them, and where"*.
+
+**`run_gates`** runs the sixteen [OperStack content gates](https://www.npmjs.com/package/@operstack/gates) on a folder of Markdown or MDX on your own machine: cut titles, copied paragraphs, hollow sections, dead links, redirect chains, a stale agent index, figures with no source, and the agent surface. Files are read locally and sent nowhere.
+
+## What it will not do
+
+It will not invent a number. Where something was not measured it says so and why. It will not score a site on data that costs money: every figure comes from what any stranger can read on the site for nothing, which means you can reproduce it yourself. It will not report on a site that did not answer: a typo in the address gets a refusal, not a page of findings about nothing.
+
+It keeps nothing. The address you check is used for the request and forgotten. There is no telemetry, no cache and no account.
+
+## Why the numbers match the paid report
+
+Every measurement here runs through [`@operstack/audit`](https://www.npmjs.com/package/@operstack/audit), the same package behind the paid OperStack reports. A free tool that disagrees with the paid one is the fastest way to lose the reader, so they are the same code.
+
+## Related
+
+- [Sixteen content gates](https://www.npmjs.com/package/@operstack/gates), free, MIT
+- [Astro starter](https://github.com/oper-stack/astro-starter) that already passes them, free, MIT
+- [Free llms.txt checker in the browser](https://oper-stack.com/tools/llms-txt-checker/)
+- [Free AI visibility check](https://oper-stack.com/ai-visibility/)
+
+MIT.

package/bin/operstack-mcp.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/** Точка входа MCP-сервера OperStack. Общение идёт по stdio, поэтому сюда нельзя печатать
+ *  ничего своего: любая посторонняя строка в stdout ломает протокол. */
+import { run } from '../src/server.mjs';
+
+run().catch((e) => {
+  process.stderr.write(`operstack-mcp failed to start: ${e.message}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@operstack/mcp",
+  "version": "0.1.0",
+  "description": "MCP server that lets Claude, Cursor and any MCP client measure a site the way a search engine and an AI read it: AI visibility score, llms.txt health, the sixteen content gates, and a full public-signal audit. Free data only, no account, nothing stored.",
+  "type": "module",
+  "license": "MIT",
+  "author": "OperStack",
+  "homepage": "https://oper-stack.com/products/mcp/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oper-stack/mcp-server.git"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "seo",
+    "aeo",
+    "geo",
+    "llms-txt",
+    "ai-visibility",
+    "claude",
+    "cursor",
+    "site-audit"
+  ],
+  "bin": {
+    "operstack-mcp": "bin/operstack-mcp.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "start": "node bin/operstack-mcp.mjs",
+    "test": "node src/test-tools.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@operstack/audit": "^0.13.1",
+    "zod": "^4.6.2"
+  }
+}

package/src/llms.mjs

@@ -0,0 +1,115 @@
+/**
+ * Проверка llms.txt: тот же разбор, что на oper-stack.com, только без браузера.
+ *
+ * Простым языком: llms.txt это список ваших страниц, написанный для программ. Ассистент читает его
+ * вместо того, чтобы обходить весь сайт. Файл ставят один раз и забывают, а сайт живёт дальше, и
+ * через полгода половина ссылок ведёт в никуда. Человек этого не замечает, потому что этот адрес не
+ * открывает никто.
+ */
+const UA = 'Mozilla/5.0 (compatible; OperStackMCP/0.1; +https://oper-stack.com/products/mcp/)';
+
+const LINK_RE = /^\s*[-*]\s*\[([^\]]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)\s*:?\s*(.*)$/;
+const BARE_RE = /^\s*[-*]\s*(https?:\/\/\S+|\/\S+)\s*(?:[:—–-]\s*(.*))?$/;
+
+export function parseLlms(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  let title = null; let summary = null;
+  const sections = []; const links = []; let bare = 0;
+  for (const line of lines) {
+    const h1 = /^#\s+(.+)$/.exec(line);
+    if (h1 && !title) { title = h1[1].trim(); continue; }
+    const h2 = /^##\s+(.+)$/.exec(line);
+    if (h2) { sections.push(h2[1].trim()); continue; }
+    const q = /^>\s*(.+)$/.exec(line);
+    if (q && !summary) { summary = q[1].trim(); continue; }
+    const m = LINK_RE.exec(line);
+    if (m) { links.push({ title: m[1].trim(), url: m[2].trim() }); continue; }
+    const b = BARE_RE.exec(line);
+    if (b) { bare++; links.push({ title: (b[2] || '').trim() || '(no title)', url: b[1].trim() }); }
+  }
+  return { title, summary, sections, links, bare };
+}
+
+export function normaliseSite(raw) {
+  const s = String(raw || '').trim();
+  if (!s) throw new Error('give the address of a site');
+  const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(s);
+  if (scheme && !/^https?$/i.test(scheme[1])) throw new Error('only http and https addresses work');
+  const u = new URL(/^https?:\/\//i.test(s) ? s : `https://${s}`);
+  if (!/^[a-z0-9.-]+\.[a-z]{2,}$/i.test(u.hostname)) throw new Error(`that does not look like a domain name: ${u.hostname}`);
+  // Зарезервированные имена ловим и с конца: internal.localhost и box.local проходят проверку на
+  // домен, но всегда указывают внутрь машины или сети.
+  if (/^(localhost|127\.|10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.|0\.|\[)/i.test(u.hostname)
+    || /\.(localhost|local|internal|test|example|invalid|home|lan|intranet)$/i.test(u.hostname)) {
+    throw new Error('a local address is not reachable from the outside');
+  }
+  return u.origin;
+}
+
+async function head(url, ms) {
+  try {
+    const r = await fetch(url, { method: 'HEAD', headers: { 'user-agent': UA }, redirect: 'manual', signal: AbortSignal.timeout(ms) });
+    if (r.status === 405 || r.status === 501) {
+      const g = await fetch(url, { headers: { 'user-agent': UA }, redirect: 'manual', signal: AbortSignal.timeout(ms) });
+      return { status: g.status, location: g.headers.get('location') || undefined };
+    }
+    return { status: r.status, location: r.headers.get('location') || undefined };
+  } catch { return { status: null }; }
+}
+
+export async function checkLlms(site, { maxLinks = 20, timeoutMs = 8000 } = {}) {
+  const origin = normaliseSite(site);
+  const url = `${origin}/llms.txt`;
+  let text = null; let status = null;
+  try {
+    const r = await fetch(url, { headers: { 'user-agent': UA }, redirect: 'follow', signal: AbortSignal.timeout(timeoutMs) });
+    status = r.status;
+    if (r.ok) text = await r.text();
+  } catch { /* нет ответа */ }
+
+  if (text === null) {
+    return {
+      site: origin, url, found: false, status,
+      verdict: 'missing',
+      findings: [{ level: 'fail', message: status ? `no file at ${url}: the server answered ${status}` : `${url} did not answer` }],
+      links: [],
+    };
+  }
+
+  const p = parseLlms(text);
+  const findings = [];
+  if (!p.title) findings.push({ level: 'fail', message: 'no H1 naming the site on the first line, which the format requires' });
+  else findings.push({ level: 'ok', message: `names the site: ${p.title}` });
+  if (!p.summary) findings.push({ level: 'warn', message: 'no blockquote summary under the heading' });
+  if (!p.sections.length) findings.push({ level: 'warn', message: 'no sections grouping the links' });
+  if (!p.links.length) findings.push({ level: 'fail', message: 'lists no links at all' });
+  else if (p.bare === p.links.length) findings.push({ level: 'warn', message: `all ${p.links.length} links are bare addresses; the format asks for [title](address) so a reader knows what is behind each one` });
+  else if (p.bare) findings.push({ level: 'warn', message: `${p.bare} of ${p.links.length} links are bare addresses` });
+
+  const sample = p.links.slice(0, maxLinks);
+  const checked = await Promise.all(sample.map(async (l) => {
+    let abs = l.url;
+    try { abs = new URL(l.url, `${origin}/`).href; } catch { /* как есть */ }
+    const r = await head(abs, Math.min(4000, timeoutMs));
+    return { title: l.title, url: abs, status: r.status, ...(r.location ? { redirectsTo: new URL(r.location, abs).href } : {}) };
+  }));
+  const dead = checked.filter((l) => l.status === null || l.status >= 400);
+  const moved = checked.filter((l) => l.status !== null && l.status >= 300 && l.status < 400);
+  if (dead.length) findings.push({ level: 'fail', message: `${dead.length} of ${checked.length} checked links lead nowhere` });
+  if (moved.length) findings.push({ level: 'warn', message: `${moved.length} of ${checked.length} checked links redirect` });
+  if (checked.length && !dead.length && !moved.length) findings.push({ level: 'ok', message: `all ${checked.length} checked links answer directly` });
+
+  let full = false;
+  try { full = (await fetch(`${origin}/llms-full.txt`, { method: 'HEAD', headers: { 'user-agent': UA }, signal: AbortSignal.timeout(3000) })).ok; } catch { /* нет */ }
+  if (full) findings.push({ level: 'ok', message: 'llms-full.txt is there too' });
+
+  const fails = findings.filter((f) => f.level === 'fail').length;
+  const warns = findings.filter((f) => f.level === 'warn').length;
+  return {
+    site: origin, url, found: true, bytes: text.length,
+    title: p.title, summary: p.summary, sections: p.sections,
+    linksListed: p.links.length, linksChecked: checked.length, hasFullText: full,
+    verdict: fails ? 'broken' : warns ? 'needs work' : 'good',
+    findings, links: checked,
+  };
+}

package/src/server.mjs

@@ -0,0 +1,157 @@
+/**
+ * MCP-сервер OperStack.
+ *
+ * Простым языком. Это надстройка, которая даёт Claude, Cursor и любому другому клиенту MCP
+ * измерить сайт так, как его читают поисковик и ИИ: сколько текста они видят, есть ли карта для
+ * агентов, куда ведут ссылки в ней, и что мешает вас процитировать. Вы спрашиваете ассистента
+ * обычными словами, он сам зовёт нужную проверку и отвечает по её результатам.
+ *
+ * Что важно: ничего не хранится, аккаунт не нужен, и ни одна цифра не берётся из платного сервиса.
+ * Всё, что здесь считается, посчитано из того, что любой посторонний читает на сайте бесплатно.
+ *
+ * Технически: stdio-сервер на официальном SDK. Инструменты тонкие, вся работа в @operstack/audit,
+ * том же пакете, на котором сделаны платные отчёты. Поэтому цифра, которую увидит здесь человек,
+ * совпадает с цифрой в отчёте, за который платят: расхождение между бесплатным и платным
+ * инструментом это худший способ потерять доверие.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { collect, localiseChecks, AREAS_RU } from '@operstack/audit';
+import { checkLlms, normaliseSite } from './llms.mjs';
+
+export const VERSION = '0.1.0';
+
+const text = (value) => ({ content: [{ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) }] });
+const fail = (message) => ({ content: [{ type: 'text', text: message }], isError: true });
+
+/** Компактная сводка аудита: клиенту не нужен весь JSON на сорок проверок, ему нужен вывод. */
+function summarise(audit, lang) {
+  const ru = lang === 'ru';
+  const checks = ru ? localiseChecks(audit.checks || [], 'ru') : (audit.checks || []);
+  const areaName = (k) => (ru ? (AREAS_RU[k] || k) : k);
+  const open = checks.filter((c) => c.status === 'bad' || c.status === 'warn');
+  return {
+    site: audit.meta?.site,
+    reachable: audit.meta?.reachable !== false,
+    collectedAt: audit.meta?.collectedAt,
+    pagesSampled: (audit.sample || []).filter((p) => p.title !== undefined).length,
+    scores: Object.fromEntries(Object.entries(audit.scores || {}).map(([k, v]) => [areaName(k), v ?? (ru ? 'не измерялось' : 'not measured')])),
+    failing: checks.filter((c) => c.status === 'bad').map((c) => ({ check: c.label, found: c.value })),
+    needsAttention: checks.filter((c) => c.status === 'warn').map((c) => ({ check: c.label, found: c.value })),
+    passing: checks.filter((c) => c.status === 'ok').length,
+    openCount: open.length,
+    note: ru
+      ? 'Каждая цифра посчитана из того, что любой посторонний читает на сайте бесплатно. Ничего не сохранено.'
+      : 'Every figure is computed from what any stranger can read on the site for nothing. Nothing was stored.',
+  };
+}
+
+export function buildServer() {
+  const server = new McpServer({ name: 'operstack', version: VERSION });
+
+  server.registerTool(
+    'audit_site',
+    {
+      title: 'Audit a site the way a search engine and an AI read it',
+      description:
+        'Read a public site and score six areas out of ten: technical SEO, content and structure, AEO (whether an answer engine can quote it), GEO (whether AI systems can identify and use it), off-page trust, and conversion. Returns every failing and borderline check with what was actually found on the pages. Free public signals only: no account, no paid tool, nothing stored. Use it when someone asks why a site is not being cited, why AI assistants recommend competitors, or what to fix first.',
+      inputSchema: {
+        url: z.string().describe('The site to read, for example example.com or https://example.com/'),
+        pages: z.number().int().min(1).max(40).optional().describe('How many pages to sample from the sitemap. Default 12; more pages take longer.'),
+        lang: z.enum(['en', 'ru']).optional().describe('Language of the check names and findings. Default en.'),
+      },
+    },
+    async ({ url, pages = 12, lang = 'en' }) => {
+      let site;
+      try { site = normaliseSite(url); } catch (e) { return fail(e.message); }
+      try {
+        const audit = await collect(site, { pages, lang, rendered: false, log: () => {} });
+        if (audit.meta?.reachable === false) return fail(`${site} did not answer. Check the address: a report about a site that is not there would be invented.`);
+        return text(summarise(audit, lang));
+      } catch (e) {
+        return fail(`could not read ${site}: ${e.message}`);
+      }
+    },
+  );
+
+  server.registerTool(
+    'check_llms_txt',
+    {
+      title: 'Check the llms.txt map a site offers to AI',
+      description:
+        'Read a site\'s /llms.txt, check it against the format (one H1 naming the site, a summary, sections of links) and follow its links to see whether each still leads to a page, a redirect or nothing. This file rots silently because no human ever opens it. Use it when someone asks whether their llms.txt is correct, why an assistant quotes the wrong pages, or before publishing a new one.',
+      inputSchema: {
+        url: z.string().describe('The site to check, for example example.com'),
+        maxLinks: z.number().int().min(1).max(50).optional().describe('How many links to follow. Default 20.'),
+      },
+    },
+    async ({ url, maxLinks = 20 }) => {
+      try { return text(await checkLlms(url, { maxLinks })); }
+      catch (e) { return fail(e.message); }
+    },
+  );
+
+  server.registerTool(
+    'run_gates',
+    {
+      title: 'Run the sixteen OperStack content gates on a local project',
+      description:
+        'Run the sixteen quality gates on a folder of Markdown or MDX content on this machine: cut titles, copied paragraphs, hollow sections, dead links, redirect chains, a stale agent index, figures with no source, and the agent surface. Returns the report. Use it before publishing, or when asked what is wrong with a content corpus. It needs a local path, not a URL, and it reads files without sending them anywhere.',
+      inputSchema: {
+        path: z.string().describe('Absolute path to the project folder that holds the content'),
+        only: z.string().optional().describe('Comma-separated gate numbers to run, for example 1,4,16. Default all.'),
+      },
+    },
+    async ({ path: dir, only }) => {
+      if (!existsSync(dir)) return fail(`no such folder: ${dir}`);
+      const args = ['--yes', '@operstack/gates'];
+      if (only) args.push('--only', only);
+      const r = spawnSync('npx', args, { cwd: dir, encoding: 'utf8', timeout: 10 * 60 * 1000, env: process.env });
+      const out = `${r.stdout || ''}${r.stderr || ''}`.trim();
+      if (!out) return fail(`the gates produced no output in ${dir}. Is there a content folder there?`);
+      return text(out);
+    },
+  );
+
+  server.registerTool(
+    'compare_sites',
+    {
+      title: 'Compare a site with its rivals on the same measurements',
+      description:
+        'Run the same six-area measurement on two to four public sites and return them side by side. Use it when someone asks why a competitor is being quoted instead of them, or wants to know where the gap actually is rather than guessing. Free public signals only.',
+      inputSchema: {
+        urls: z.array(z.string()).min(2).max(4).describe('The sites to compare. The first one is treated as yours.'),
+        pages: z.number().int().min(1).max(20).optional().describe('Pages to sample per site. Default 8.'),
+        lang: z.enum(['en', 'ru']).optional(),
+      },
+    },
+    async ({ urls, pages = 8, lang = 'en' }) => {
+      const rows = [];
+      for (const raw of urls) {
+        let site;
+        try { site = normaliseSite(raw); } catch (e) { rows.push({ site: raw, error: e.message }); continue; }
+        try {
+          const audit = await collect(site, { pages, lang, rendered: false, log: () => {} });
+          if (audit.meta?.reachable === false) { rows.push({ site, error: 'did not answer' }); continue; }
+          const ru = lang === 'ru';
+          rows.push({
+            site,
+            scores: Object.fromEntries(Object.entries(audit.scores || {}).map(([k, v]) => [ru ? (AREAS_RU[k] || k) : k, v ?? null])),
+            openCount: (audit.checks || []).filter((c) => c.status !== 'ok').length,
+          });
+        } catch (e) { rows.push({ site, error: e.message }); }
+      }
+      return text({ yours: rows[0]?.site, comparison: rows, note: 'Same measurement on every site, taken from the outside. Nothing stored.' });
+    },
+  );
+
+  return server;
+}
+
+export async function run() {
+  const server = buildServer();
+  await server.connect(new StdioServerTransport());
+}

package/src/test-tools.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * Проверка сервера так, как его увидит клиент: поднимаем настоящий процесс, соединяемся по stdio,
+ * спрашиваем список инструментов и зовём каждый. Проверять внутренние функции в обход протокола
+ * бессмысленно: сломаться может именно стык.
+ *
+ *   npm test
+ *   npm test -- --live     ещё и сходить на живой сайт (медленнее, нужна сеть)
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const LIVE = process.argv.includes('--live');
+
+let failed = 0;
+const ok = (name, cond, detail = '') => {
+  if (cond) console.log(`ok   ${name}`);
+  else { failed++; console.error(`FAIL ${name}${detail ? `\n     ${detail}` : ''}`); }
+};
+
+const firstText = (r) => (r?.content || []).filter((c) => c.type === 'text').map((c) => c.text).join('\n');
+
+async function main() {
+  const client = new Client({ name: 'operstack-test', version: '1.0.0' });
+  await client.connect(new StdioClientTransport({
+    command: process.execPath,
+    args: [resolve(ROOT, 'bin/operstack-mcp.mjs')],
+  }));
+
+  const { tools } = await client.listTools();
+  const names = tools.map((t) => t.name).sort();
+  ok('сервер отвечает списком инструментов', tools.length > 0, `получено: ${names.join(', ')}`);
+  ok('есть все четыре инструмента', ['audit_site', 'check_llms_txt', 'compare_sites', 'run_gates'].every((n) => names.includes(n)), names.join(', '));
+  ok('у каждого инструмента есть описание', tools.every((t) => (t.description || '').length > 60), tools.filter((t) => (t.description || '').length <= 60).map((t) => t.name).join(', '));
+  ok('у каждого инструмента есть схема входа', tools.every((t) => t.inputSchema && t.inputSchema.type === 'object'));
+
+  // Отказы: их проверяем всегда, сеть для них не нужна.
+  for (const bad of ['localhost', '127.0.0.1', '192.168.1.1', 'internal.localhost']) {
+    const r = await client.callTool({ name: 'check_llms_txt', arguments: { url: bad } });
+    ok(`внутренний адрес отвергнут: ${bad}`, r.isError === true && /(local address|domain name)/i.test(firstText(r)), firstText(r));
+  }
+
+  const scheme = await client.callTool({ name: 'audit_site', arguments: { url: 'ftp://example.com' } });
+  ok('чужая схема отвергнута', scheme.isError === true && /http and https/i.test(firstText(scheme)), firstText(scheme));
+
+  const nodir = await client.callTool({ name: 'run_gates', arguments: { path: '/no/such/folder/anywhere' } });
+  ok('несуществующая папка отвергнута', nodir.isError === true && /no such folder/i.test(firstText(nodir)), firstText(nodir));
+
+  if (LIVE) {
+    const llms = await client.callTool({ name: 'check_llms_txt', arguments: { url: 'oper-stack.com', maxLinks: 5 } });
+    const parsed = JSON.parse(firstText(llms));
+    ok('живая проверка llms.txt нашла файл', parsed.found === true, firstText(llms).slice(0, 200));
+    ok('живая проверка вернула вердикт', ['good', 'needs work', 'broken'].includes(parsed.verdict), parsed.verdict);
+
+    const audit = await client.callTool({ name: 'audit_site', arguments: { url: 'oper-stack.com', pages: 3 } });
+    const a = JSON.parse(firstText(audit));
+    ok('живой аудит вернул оценки', a.scores && Object.keys(a.scores).length === 6, JSON.stringify(a.scores));
+    ok('живой аудит отметил сайт достижимым', a.reachable === true);
+
+    const dead = await client.callTool({ name: 'audit_site', arguments: { url: 'this-domain-does-not-exist-operstack-test.com', pages: 2 } });
+    ok('мёртвый домен отвергнут, а не оценён', dead.isError === true && /did not answer/i.test(firstText(dead)), firstText(dead));
+  } else {
+    console.log('...  живые проверки пропущены (запустите с --live)');
+  }
+
+  await client.close();
+  if (failed) { console.error(`\n${failed} проверок упало`); process.exit(1); }
+  console.log('\nсервер отвечает как положено');
+}
+
+main().catch((e) => { console.error(e); process.exit(1); });