mcplane 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steve Smith
+
+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,201 @@
+# mcplane
+
+**fastlane for MCP servers.** mcplane checks your server against the reasons each store rejects submissions. It publishes wherever a store allows automation and prepares everything the form-based stores ask for. It keeps every listing in step with your live server. Run it as a CLI, in CI, or as an MCP server driven by your coding agent.
+
+```sh
+npx mcplane init --url https://mcp.example.com/mcp
+npx mcplane preflight
+```
+
+```
+✗ DNS does not advertise Encrypted ClientHello [ChatGPT]
+    example.com has ech= in its HTTPS record
+    Turn ECH off for this domain. TLS-inspecting review proxies reset ECH handshakes: three ChatGPT
+    rejections traced back to this, with nothing in the server's logs.
+✗ Every tool has a human-readable title [Claude connectors, Claude plugins]
+    search_docs, fetch_page
+    Add "title" (or annotations.title) to each tool. Anthropic rejects connectors without them.
+! A small icon is available for ChatGPT's dialogs [ChatGPT]
+    28 KB
+    ChatGPT's icon upload in developer mode caps at 10 KB. Export an 8-bit PNG.
+✓ 15 checks passed (--verbose to list them)
+
+2 blocking, 1 to review.
+```
+
+## Why
+
+An MCP server now has a dozen places to be listed: ChatGPT, Claude, Cursor, Grok, Muse, the official MCP Registry, Docker, Smithery and the directories that read from them. Each has its own form, its own rules and its own idea of what an update is. Most rejections are for the same few mechanical things, and each one costs you days in the queue. With one app that's annoying. With seventeen you stop shipping.
+
+iOS had the same problem in 2014. fastlane fixed it by putting your metadata in the repo, checking it before Apple could reject it, and turning every release into one command. mcplane does that for agent-era stores.
+
+An agent with a browser could fill in a form. It can't tell you that your DNS will make ChatGPT's reviewer time out, that a hint needs a justification you haven't written, or which of your seventeen listings went stale on Tuesday. That's the part mcplane does.
+
+## Use it from your agent
+
+mcplane is itself an MCP server, so the agent in your repo can do the work:
+
+```sh
+claude mcp add mcplane -- npx -y mcplane mcp          # Claude Code
+codex mcp add mcplane -- npx -y mcplane mcp           # Codex
+```
+
+Cursor, VS Code and others: add a stdio server with command `npx` and args `["-y", "mcplane", "mcp"]`.
+
+Then run the **onboard** prompt (`/mcp__mcplane__onboard` in Claude Code). The agent creates `mcplane.json` and reads your code. It writes the listing copy and the review test cases (ChatGPT wants exactly 5 positive and 3 negative), runs preflight and fixes what it can. The **ship** prompt takes it from there: check, pack, publish, and a short list of what's left for you.
+
+Tools: `preflight`, `drift`, `pack`, `publish`, `record_submission`, `record_decision`, `submission_status`, `install_links`, `pull_listings`, `init`, `fleet`. Every tool takes an optional `project` folder, so one mcplane serves all your apps. Annotations are honest: `publish` and `record_*` are marked open-world, and `publish` does nothing without `confirm: true`.
+
+## Many apps
+
+```sh
+npx mcplane fleet --root ~/Projects
+```
+
+```
+✓ Review Times             preflight clean · live on chatgpt
+✗ Invoice Bot              2 blocking · waiting on claude-connectors
+✗ Weather Pro              1 store update needed
+    chatgpt: Tools changed since the live version (v1.2.0) on 2026-09-02: added forecast_hourly
+
+3 projects, 2 need attention.
+```
+
+`mcplane fleet run <command>` runs any command in every project, e.g. `mcplane fleet run publish mcp-registry --yes`.
+
+## What it does per store
+
+| Store | How mcplane gets you there | Keeping it current |
+|---|---|---|
+| Official MCP Registry | **Publishes**: writes `server.json`, runs `mcp-publisher`, signs in with GitHub OIDC in Actions. GitHub's MCP Registry (VS Code), PulseMCP and MCP.Directory read from it | Versions can't change: bump, or a prerelease like `1.2.0-1` for listing-only edits. mcplane checks what's already published |
+| Grok plugins | **Publishes**: opens the pull request to `xai-org/plugin-marketplace`, validated with xAI's own scripts | Opens a pin-bump PR when xAI's daily bump lags |
+| ChatGPT | **Prepares** `chatgpt-app-submission.json` for the portal's import: listing, tools, hint justifications, 5+3 tests | Tool changes roll out after OpenAI's automated checks. Listing text and hint justifications need a new version, and drift says when |
+| Claude connectors | **Prepares** every field of the directory form | Tool changes are live on deploy; listing edits (tool names included) are reviewed |
+| Claude plugins | **Prepares** and checks the plugin repo | The portal tracks your branch; drift tells you a new version is waiting for review |
+| Cursor | **Prepares** and checks the plugin repo | Pinned to the commit first added; drift flags when you've moved on |
+| Muse | **Prepares** the form | Flags changes |
+| Cline, Glama, LobeHub, Smithery, Docker, awesome-mcp-servers | The prefilled issue, `glama.json`, CLI command or entry | |
+| mcp.so, MCP Market, mcpservers.org, cursor.directory | `mcplane pack directories`: one sheet with every value to paste | |
+
+**What stays with you, and why.** The ChatGPT and Claude portals have no submission API. Neither do most directories. They ask you to make statements about policy, data use and testing that only you can make. mcplane gets you to the final click with every field filled and every known rejection checked. It never signs in for you, never ticks attestations and never gets around a bot check. If your agent has browser tools, the **ship** prompt offers to fill the form from the pack while you make the statements and press submit.
+
+## Preflight
+
+Checks come from real rejections, most of them ours:
+
+- **Server**: `initialize`, `tools/list` and `ping` work. Unknown methods return `-32601` (OpenAI's tool scan probes `server/discover` and gives up on a crash). The URL works with a trailing slash. CORS preflight answers. Automated clients aren't blocked by a bot filter. A TLS 1.2 client connects. DNS doesn't advertise Encrypted ClientHello, which review proxies reset without a trace in your logs.
+- **OAuth**: unauthenticated calls get `401` with `resource_metadata`. Protected-resource and authorization-server metadata resolve, and PKCE S256 is supported. With `--register`, Dynamic Client Registration is tested, including the `cursor://` and other native redirect schemes that locked out every desktop client for us.
+- **Tools**: every tool has a title and explicit `readOnlyHint`, `destructiveHint` and `openWorldHint`, and the hints are consistent. Tools declare `outputSchema`. Descriptions don't instruct the model. Writes aren't authorised by a token passed through the chat (Anthropic rejected exactly that). Hints follow OpenAI's current definitions: `openWorldHint` for anything that reaches the public internet (read-only web search included), `destructiveHint` for messages that can't be unsent. No catch-all request tools, no tool names over 64 characters, no sensitive inputs, no upgrade or pricing copy.
+- **Listing**: the icon is a square PNG of at least 512px behind a direct link, and `/favicon.ico` resolves. The privacy policy covers collection, retention and user controls. Support is a web page. Name, subtitle, one-liner, description and starter prompts fit each store's limits. The ChatGPT domain challenge is served.
+- **Plugin repo**: public, on GitHub, with `.claude-plugin/plugin.json`, and no root `SKILL.md` shadowing the plugin's skills. Grok plugins come from an organisation.
+
+`--json` for machines; exit code 1 when something blocks.
+
+## Keeping listings current
+
+Every store calls your live server, so fixes reach users on their own. What doesn't: listing text, tool names in Claude's listing, ChatGPT's hint justifications, registry versions and plugins pinned to a commit. Each store has different rules for these. When you record a submission, mcplane snapshots what the store is reviewing. `mcplane drift` compares your live server and `mcplane.json` against that snapshot and tells you what each store needs.
+
+```sh
+mcplane submitted chatgpt --version 1.2.0 --app-id asdk_app_…
+mcplane drift          # later, after you change things
+mcplane baseline claude-connectors   # for listings that were live before you used mcplane
+```
+
+Snapshots live in `.mcplane/snapshots` and are meant to be committed, so CI can catch drift. Submissions and packs stay local (mcplane writes the `.gitignore`).
+
+## Lanes
+
+Like fastlane's lanes: named workflows in `mcplane.json`.
+
+```json
+"lanes": {
+  "check": ["preflight", "drift --ci"],
+  "release": ["preflight", "drift", "pack chatgpt", "pack claude-connectors", "publish mcp-registry --yes", "?publish grok --yes",
+              "handoff: Upload the ChatGPT JSON and submit, then: mcplane submitted chatgpt"]
+}
+```
+
+`mcplane release` runs the steps in order and stops at the first failure. A `?` step may fail without stopping the lane. `handoff:` steps are listed at the end as your to-do. `check` and `release` are built in.
+
+## CI
+
+```yaml
+# .github/workflows/mcplane.yml
+on: [push]
+jobs:
+  stores:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: stevysmith/mcplane@v0
+        with:
+          command: check   # preflight + drift --ci
+```
+
+Publishing to the MCP Registry from CI needs no secrets for `io.github.*` names:
+
+```yaml
+  release:
+    runs-on: ubuntu-latest
+    permissions: { id-token: write, contents: read }
+    steps:
+      - uses: actions/checkout@v4
+      - run: |
+          curl -L "https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_linux_amd64.tar.gz" | tar xz mcp-publisher
+          sudo mv mcp-publisher /usr/local/bin/
+      - uses: stevysmith/mcplane@v0
+        with:
+          command: publish mcp-registry --yes
+```
+
+For a reverse-DNS name, set an `MCP_PRIVATE_KEY` secret and mcplane signs in with `login dns`.
+
+## Review Times
+
+`mcplane submitted` logs an anonymous report to [Review Times](https://reviewtimes.fyi), the public tracker of how long each store takes to review. The report holds the store, dates, the kind of submission and the public listing reference that lets it close itself when your listing appears. No code, names or email. `mcplane status` shows how long each of yours has waited next to each store's typical wait. `--private` (or `share: false`) keeps it local.
+
+## Commands
+
+```
+init --url <mcp url>          Create mcplane.json from your live server
+preflight [--store <id>]      Check against every store's rejection causes (--url, --json, --verbose, --register, --token)
+pack <store>                  Write a submission pack to .mcplane/packs (or "pack directories")
+publish <store> [--yes]       Publish where the store allows it; dry run without --yes
+submitted <store>             Record a submission (--date, --kind, --version, --app-id, --private)
+decided <store> <outcome>     approved | rejected | withdrawn
+status                        Your submissions, days waited, each store's typical wait
+drift [--ci]                  What each store needs since it last saw your server
+baseline <store>              Mark an existing live listing as the drift baseline
+pull                          Compare live public listings with mcplane.json
+try                           Install links for every client, for you and your testers
+fleet [--root <dir>]          Every project at a glance (--quick, --json, --ci)
+fleet run <command...>        Run a command in every project
+lanes / <lane>                List lanes / run one
+mcp                           Run as an MCP server over stdio
+```
+
+Servers behind sign-in: pass `--token` or set `MCPLANE_TOKEN` so tool checks can run.
+
+## mcplane.json
+
+One file describes your server and its listings. [`schema.json`](schema.json) gives editors completion and validation; `mcplane init` adds the `$schema` line. [`examples/mcplane.json`](examples/mcplane.json) is a complete one, from [Review Times](https://reviewtimes.fyi)' own ChatGPT and Claude submissions.
+
+## fastlane, mapped
+
+| fastlane | mcplane |
+|---|---|
+| `precheck` | `preflight` |
+| `deliver` + metadata in the repo | `mcplane.json`, `pack`, `publish` |
+| `download_metadata` | `pull` |
+| `pilot` (TestFlight testers) | `try`: install links for every client |
+| Fastfile lanes | `lanes` |
+| `fastlane init` | `init`, and the **onboard** prompt that writes the listing for you |
+| CI-first | `--ci` exit codes, JSON output, GitHub Action |
+| New: agent-driven | the whole thing is an MCP server |
+| New: drift | knows what each store needs when your server changes |
+
+## Contributing
+
+Stores and checks are small, separate modules. To add a store: add its id to `src/types.ts`, its rules to `src/drift.ts`, a pack or publisher in `src/packs.ts` or `src/publish.ts`, and a row above. To add a check: a function in `src/checks/`, with the rejection it prevents in the `fix` text. The best contributions are rejections you've had. Open an issue with what the reviewer said.
+
+MIT licensed.

package/dist/checks/auth.js

@@ -0,0 +1,72 @@
+const REDIRECTS = {
+    chatgpt: ['https://chatgpt.com/connector_platform_oauth_redirect', 'https://platform.openai.com/apps-manage/oauth'],
+    claude: ['https://claude.ai/api/mcp/auth_callback'],
+    native: ['cursor://anysphere.cursor-mcp/oauth/callback', 'grok://oauth/callback'],
+};
+const json = async (url) => {
+    const res = await fetch(url, { headers: { accept: 'application/json', 'user-agent': 'mcplane' }, signal: AbortSignal.timeout(10_000) }).catch(() => null);
+    return { res, body: res?.ok ? (await res.json().catch(() => null)) : null };
+};
+export async function authChecks(url, opts = {}) {
+    const checks = [];
+    const u = new URL(url);
+    // An unauthenticated call must say how to sign in.
+    const bare = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', accept: 'application/json, text/event-stream', 'user-agent': 'mcplane' },
+        body: '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"mcplane","version":"0.1.0"}}}',
+    }).catch(() => null);
+    const www = bare?.headers.get('www-authenticate') ?? '';
+    if (bare?.status === 401 && /resource_metadata=/i.test(www)) {
+        checks.push({ id: 'auth.401', level: 'pass', title: 'Unauthenticated calls get 401 with resource_metadata' });
+    }
+    else {
+        checks.push({
+            id: 'auth.401',
+            level: 'fail',
+            title: 'Unauthenticated calls get 401 with resource_metadata',
+            detail: `HTTP ${bare?.status ?? 'error'}${www ? `, WWW-Authenticate: ${www.slice(0, 120)}` : ', no WWW-Authenticate'}`,
+            fix: 'Answer unauthenticated MCP requests with 401 and WWW-Authenticate: Bearer resource_metadata="<origin>/.well-known/oauth-protected-resource". Never 403: to a reviewer a 403 is "unable to connect".',
+        });
+    }
+    // Protected-resource metadata, on the MCP host itself.
+    const prm = (await json(`${u.origin}/.well-known/oauth-protected-resource${u.pathname === '/' ? '' : u.pathname}`)).body ?? (await json(`${u.origin}/.well-known/oauth-protected-resource`)).body;
+    const asUrl = prm?.authorization_servers?.[0];
+    checks.push(asUrl
+        ? { id: 'auth.prm', level: 'pass', title: 'Protected-resource metadata resolves on the MCP host', detail: `authorization server ${asUrl}` }
+        : { id: 'auth.prm', level: 'fail', title: 'Protected-resource metadata resolves on the MCP host', fix: `Serve ${u.origin}/.well-known/oauth-protected-resource with "resource" and "authorization_servers". Clients resolve it against the MCP URL's own host, not your apex domain.` });
+    if (!asUrl)
+        return checks;
+    const asOrigin = new URL(asUrl).origin;
+    const asm = (await json(`${asOrigin}/.well-known/oauth-authorization-server`)).body ?? (await json(`${asOrigin}/.well-known/openid-configuration`)).body;
+    if (!asm) {
+        checks.push({ id: 'auth.as-metadata', level: 'fail', title: 'Authorization-server metadata resolves', fix: `Serve ${asOrigin}/.well-known/oauth-authorization-server.` });
+        return checks;
+    }
+    checks.push({ id: 'auth.as-metadata', level: 'pass', title: 'Authorization-server metadata resolves' });
+    checks.push((asm.code_challenge_methods_supported ?? []).includes('S256')
+        ? { id: 'auth.pkce', level: 'pass', title: 'PKCE (S256) is supported' }
+        : { id: 'auth.pkce', level: 'fail', title: 'PKCE (S256) is supported', fix: 'Advertise code_challenge_methods_supported: ["S256"].' });
+    checks.push(asm.registration_endpoint
+        ? { id: 'auth.dcr', level: 'pass', title: 'Dynamic Client Registration is offered' }
+        : { id: 'auth.dcr', level: 'warn', title: 'Dynamic Client Registration is offered', fix: 'Offer a registration_endpoint (RFC 7591). Anthropic says DCR works best with its directory, and ChatGPT registers itself this way.', stores: ['claude-connectors', 'chatgpt'] });
+    if (opts.register && asm.registration_endpoint) {
+        for (const [who, uris] of Object.entries(REDIRECTS)) {
+            const r = await fetch(asm.registration_endpoint, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ client_name: `mcplane-preflight-${who}`, redirect_uris: uris, grant_types: ['authorization_code', 'refresh_token'], response_types: ['code'], token_endpoint_auth_method: 'none' }),
+            }).catch(() => null);
+            checks.push(r && (r.status === 201 || r.status === 200)
+                ? { id: `auth.dcr-${who}`, level: 'pass', title: `Registration accepts ${who} redirect URIs` }
+                : {
+                    id: `auth.dcr-${who}`,
+                    level: 'fail',
+                    title: `Registration accepts ${who} redirect URIs`,
+                    detail: `HTTP ${r?.status ?? 'error'}: ${uris.join(', ')}`,
+                    fix: who === 'native' ? 'Accept private-use URI schemes (RFC 8252). Rejecting them locks out every native client: Cursor, Grok, desktop apps.' : 'Allow these redirect URIs in client registration.',
+                });
+        }
+    }
+    return checks;
+}

package/dist/checks/listing.js

@@ -0,0 +1,149 @@
+const get = (url) => fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(12_000), headers: { 'user-agent': 'mcplane' } }).catch(() => null);
+/** Width and height from a PNG's IHDR chunk. */
+function pngSize(buf) {
+    if (buf.length < 24 || buf[0] !== 0x89 || buf[1] !== 0x50)
+        return null;
+    const v = new DataView(buf.buffer, buf.byteOffset);
+    return { w: v.getUint32(16), h: v.getUint32(20) };
+}
+const has = (stores, ...s) => s.some((x) => stores.includes(x));
+export async function listingChecks(m, tools, stores) {
+    const checks = [];
+    const origin = new URL(m.server.url).origin;
+    // Icon
+    if (!m.icon) {
+        checks.push({ id: 'listing.icon', level: 'warn', title: 'An icon URL is set', fix: 'Set "icon" to a direct PNG URL, at least 512×512. ChatGPT needs one uploaded; Claude asks for a direct .png/.svg URL when the favicon fails.' });
+    }
+    else {
+        const res = await get(m.icon);
+        const type = res?.headers.get('content-type') ?? '';
+        const buf = res?.ok ? new Uint8Array(await res.arrayBuffer()) : null;
+        const size = buf ? pngSize(buf) : null;
+        if (!res?.ok) {
+            checks.push({ id: 'listing.icon', level: 'fail', title: 'The icon URL loads', detail: `HTTP ${res?.status ?? 'error'}`, fix: 'Point "icon" at a URL that returns the image directly.' });
+        }
+        else if (!/\.(png|svg|jpe?g|gif|ico|webp)(\?|$)/i.test(m.icon)) {
+            checks.push({ id: 'listing.icon', level: 'warn', title: 'The icon URL ends in an image extension', detail: m.icon, fix: 'Anthropic asks for an icon URL ending in .png, .svg, .jpg, .gif, .ico or .webp.', stores: ['claude-connectors'] });
+        }
+        else if (type.includes('png') && size && (size.w < 512 || size.w !== size.h)) {
+            checks.push({ id: 'listing.icon', level: 'warn', title: 'The icon is square and at least 512 px', detail: `${size.w}×${size.h}`, fix: 'Use a square PNG of 512×512 or more; ChatGPT’s directory icon must be at least 256, and a 512 master covers every store.' });
+        }
+        else {
+            checks.push({ id: 'listing.icon', level: 'pass', title: 'The icon loads', detail: `${type}${size ? `, ${size.w}×${size.h}` : ''}, ${buf ? Math.round(buf.length / 1024) : '?'} KB` });
+            if (buf && buf.length > 10 * 1024 && has(stores, 'chatgpt')) {
+                checks.push({ id: 'listing.icon-small', level: 'warn', title: 'A small icon is available for ChatGPT’s dialogs', detail: `${Math.round(buf.length / 1024)} KB`, fix: 'ChatGPT’s icon upload in developer mode caps at 10 KB. Export an 8-bit PNG (pngquant or `magick in.png PNG8:out.png`).', stores: ['chatgpt'] });
+            }
+        }
+    }
+    // Favicon, the fallback Claude's directory reads.
+    const fav = await get(`${origin}/favicon.ico`);
+    checks.push(fav?.ok
+        ? { id: 'listing.favicon', level: 'pass', title: '/favicon.ico resolves on the server’s domain' }
+        : { id: 'listing.favicon', level: 'warn', title: '/favicon.ico resolves on the server’s domain', detail: `HTTP ${fav?.status ?? 'error'}`, fix: `Serve ${origin}/favicon.ico. Anthropic's reviewers reported "the fallback favicon is not resolving" when this 404'd.`, stores: ['claude-connectors'] });
+    // Privacy policy
+    const privacyUrl = m.links?.privacy;
+    if (!privacyUrl) {
+        checks.push({ id: 'listing.privacy', level: 'fail', title: 'A privacy policy is linked', fix: 'Every store requires one. Add links.privacy.' });
+    }
+    else {
+        const res = await get(privacyUrl);
+        const text = res?.ok ? (await res.text()).replace(/<[^>]+>/g, ' ').toLowerCase() : '';
+        if (!res?.ok) {
+            checks.push({ id: 'listing.privacy', level: 'fail', title: 'The privacy policy loads', detail: `HTTP ${res?.status ?? 'error'}` });
+        }
+        else {
+            const missing = [
+                !/(retain|retention|how long|keep (it|them|your)|deleted? after)/.test(text) && 'how long data is kept',
+                !/(delete|remove|unsubscribe|opt out|your (rights|choices))/.test(text) && 'what users can do about their data',
+                !/(collect|store|we keep|information we)/.test(text) && 'what is collected',
+            ].filter(Boolean);
+            checks.push(missing.length
+                ? { id: 'listing.privacy', level: 'warn', title: 'The privacy policy covers what reviewers look for', detail: `doesn’t seem to cover: ${missing.join(', ')}`, fix: 'OpenAI requires the policy to describe the data collected, its use, sharing, retention timelines and user controls.', stores: ['chatgpt'] }
+                : { id: 'listing.privacy', level: 'pass', title: 'The privacy policy covers collection, retention and user controls' });
+            // Tools that take free-form content need that disclosed.
+            const freeForm = tools.filter((t) => Object.keys(t.inputSchema?.properties ?? {}).some((k) => /^(html|content|body|document|message|text|file|markdown)$/i.test(k)));
+            if (freeForm.length && !/(content|document|html|message|file)s? (you|that you|we receive|submitted|uploaded|published)/.test(text)) {
+                checks.push({
+                    id: 'listing.privacy-content',
+                    level: 'warn',
+                    title: 'Free-form content is covered by the privacy policy',
+                    detail: `${freeForm.map((t) => t.name).join(', ')} accept free-form content`,
+                    fix: 'Say what happens to content users send through these tools: what is stored, for how long, and any automatic screening for sensitive data. A "sensitive data" rejection on ChatGPT was answered by exactly this section.',
+                    stores: ['chatgpt'],
+                });
+            }
+        }
+    }
+    // Support must be a URL for ChatGPT.
+    const support = m.links?.support;
+    if (has(stores, 'chatgpt')) {
+        checks.push(support && /^https?:\/\//.test(support)
+            ? { id: 'listing.support', level: 'pass', title: 'Support is a web page', stores: ['chatgpt'] }
+            : { id: 'listing.support', level: 'fail', title: 'Support is a web page', detail: support ?? 'missing', fix: 'ChatGPT’s form wants a customer support URL, not an email address. A /support page with your email on it is enough.', stores: ['chatgpt'] });
+    }
+    // Lengths the forms enforce (some silently).
+    const len = (v, max, id, label, s) => {
+        if (v && v.length > max)
+            checks.push({ id, level: 'fail', title: `${label} fits (${max} characters)`, detail: `${v.length} characters`, stores: s });
+        else if (v)
+            checks.push({ id, level: 'pass', title: `${label} fits (${max} characters)`, stores: s });
+    };
+    if (has(stores, 'chatgpt')) {
+        len(m.title, 30, 'listing.name', 'Display name', ['chatgpt']);
+        len(m.subtitle, 30, 'listing.subtitle', 'Subtitle', ['chatgpt']);
+        const prompts = m.prompts ?? [];
+        const bad = prompts.filter((p) => p.length > 128 || /(^|\s)@\w/.test(p));
+        const dupes = prompts.filter((p, i) => prompts.findIndex((q) => q.trim().toLowerCase() === p.trim().toLowerCase()) !== i);
+        if (bad.length || dupes.length) {
+            checks.push({ id: 'listing.prompts', level: 'fail', title: 'Starter prompts are short, unique and free of @mentions', detail: [...bad.map((p) => `"${p.slice(0, 40)}…"`), ...dupes.map((p) => `duplicate: "${p.slice(0, 40)}"`)].join('; '), fix: 'ChatGPT rejects starter prompts over 128 characters, with @mentions, or repeated.', stores: ['chatgpt'] });
+        }
+        else if (prompts.length) {
+            checks.push({ id: 'listing.prompts', level: 'pass', title: 'Starter prompts are short, unique and free of @mentions', stores: ['chatgpt'] });
+        }
+    }
+    if (has(stores, 'claude-connectors', 'claude-plugins'))
+        len(m.title, 100, 'listing.claude-name', 'Name for Claude', ['claude-connectors', 'claude-plugins']);
+    if (has(stores, 'claude-connectors', 'claude-plugins'))
+        len(m.oneLiner, 200, 'listing.one-liner', 'One-liner', ['claude-connectors', 'claude-plugins']);
+    len(m.description, 2000, 'listing.description', 'Description', []);
+    // ChatGPT domain verification
+    if (has(stores, 'chatgpt')) {
+        const ch = await get(`${origin}/.well-known/openai-apps-challenge`);
+        const body = ch?.ok ? (await ch.text()).trim() : '';
+        checks.push(body && body.length < 200 && !/<html/i.test(body)
+            ? { id: 'listing.openai-challenge', level: 'pass', title: 'ChatGPT domain challenge is served', stores: ['chatgpt'] }
+            : { id: 'listing.openai-challenge', level: 'warn', title: 'ChatGPT domain challenge is served', detail: ch?.ok ? 'answers, but with a web page rather than a plain-text token' : `HTTP ${ch?.status ?? 'error'}`, fix: `The ChatGPT form gives you a token to serve as plain text at ${origin}/.well-known/openai-apps-challenge. Add it before the MCP step, or domain verification blocks submission.`, stores: ['chatgpt'] });
+    }
+    return checks;
+}
+/** Rules for plugin repositories (Claude plugins, Cursor, Grok). */
+export async function repoChecks(m, stores) {
+    if (!m.repository || !has(stores, 'claude-plugins', 'cursor', 'grok'))
+        return [];
+    const gh = m.repository.match(/github\.com\/([^/]+)\/([^/#?]+)/);
+    if (!gh)
+        return [{ id: 'repo.github', level: 'warn', title: 'The plugin repository is on GitHub', detail: m.repository, fix: 'Claude, Cursor and Grok all read plugins from a public GitHub repository.' }];
+    const [, owner, repo] = gh;
+    const api = (p) => fetch(`https://api.github.com/repos/${owner}/${repo.replace(/\.git$/, '')}${p}`, { headers: { 'user-agent': 'mcplane', accept: 'application/vnd.github+json' } }).catch(() => null);
+    const checks = [];
+    const meta = await api('');
+    if (!meta?.ok) {
+        return [{ id: 'repo.public', level: 'fail', title: 'The plugin repository is public', detail: `HTTP ${meta?.status ?? 'error'}`, fix: 'Stores pin a commit of a public repo. A private monorepo can’t host the plugin: move it to its own public repository.' }];
+    }
+    const info = (await meta.json());
+    checks.push({ id: 'repo.public', level: 'pass', title: 'The plugin repository is public' });
+    const exists = async (p) => (await api(`/contents/${p}`))?.ok ?? false;
+    if (has(stores, 'claude-plugins')) {
+        const [manifest, rootSkill, skillsDir] = await Promise.all([exists('.claude-plugin/plugin.json'), exists('SKILL.md'), exists('skills')]);
+        checks.push(manifest
+            ? { id: 'repo.claude-manifest', level: 'pass', title: '.claude-plugin/plugin.json exists', stores: ['claude-plugins'] }
+            : { id: 'repo.claude-manifest', level: 'fail', title: '.claude-plugin/plugin.json exists', fix: 'Add a plugin manifest and run `claude plugin validate`.', stores: ['claude-plugins'] });
+        if (rootSkill && skillsDir) {
+            checks.push({ id: 'repo.root-skill', level: 'warn', title: 'No root SKILL.md shadowing the plugin’s skills', fix: 'A SKILL.md at the repo root makes it load as a single-skill plugin and hides everything in skills/. Move it under skills/.', stores: ['claude-plugins'] });
+        }
+    }
+    if (has(stores, 'grok') && info.owner?.type === 'User') {
+        checks.push({ id: 'repo.grok-org', level: 'warn', title: 'Grok plugin comes from an organisation', detail: `${owner} is a personal account`, fix: 'xAI’s guide says plugins sourced from personal accounts "will be questioned". Transfer the repo to an organisation named after the product.', stores: ['grok'] });
+    }
+    return checks;
+}

package/dist/checks/server.js

@@ -0,0 +1,148 @@
+import { connect } from 'node:tls';
+import { McpClient } from '../mcp-client.js';
+const BROWSER_UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0 Safari/537.36';
+/** Connects the way a store's scanner does and returns the tool list for the other checks. */
+export async function serverChecks(url, auth, token) {
+    const checks = [];
+    const bearer = token ? { authorization: `Bearer ${token}` } : {};
+    const client = new McpClient(url, bearer);
+    let tools = [];
+    // initialize
+    let init;
+    try {
+        init = await client.initialize();
+    }
+    catch (e) {
+        checks.push({ id: 'server.reachable', level: 'fail', title: 'Server answers', detail: String(e.message), fix: `Check ${url} is live and reachable from the public internet.` });
+        return { checks, tools };
+    }
+    if (auth === 'oauth' && init.status === 401) {
+        checks.push({ id: 'server.reachable', level: 'pass', title: 'Server answers (401 until signed in, as expected)' });
+        if (token)
+            checks.push({ id: 'server.token', level: 'fail', title: 'The --token signs in', detail: 'still 401', fix: 'Pass a valid access token for your own account.' });
+        else
+            checks.push({ id: 'server.tools-skipped', level: 'skip', title: 'Tool checks skipped: the server needs sign-in', fix: 'Run again with --token <access token> from your own account to check tool titles, annotations and descriptions.' });
+    }
+    else if (init.status >= 400 || init.body?.error) {
+        checks.push({
+            id: 'server.initialize',
+            level: 'fail',
+            title: 'initialize succeeds',
+            detail: `HTTP ${init.status}${init.body?.error ? `, ${JSON.stringify(init.body.error).slice(0, 160)}` : ''}`,
+            fix: auth === 'none' ? 'An authless server must answer initialize without credentials. If it needs sign-in, set "auth": "oauth" in mcplane.json.' : undefined,
+        });
+        return { checks, tools };
+    }
+    else {
+        const info = init.body?.result?.serverInfo;
+        checks.push({ id: 'server.initialize', level: 'pass', title: 'initialize succeeds', detail: info ? `${info.name ?? ''} ${info.version ?? ''}`.trim() : undefined });
+    }
+    if (auth === 'none' || (token && init.status < 300)) {
+        const list = await client.request('tools/list').catch(() => null);
+        tools = list?.body?.result?.tools ?? [];
+        checks.push(tools.length
+            ? { id: 'server.tools', level: 'pass', title: 'tools/list returns tools', detail: tools.map((t) => t.name).join(', ') }
+            : { id: 'server.tools', level: 'fail', title: 'tools/list returns tools', detail: `HTTP ${list?.status ?? 'error'}`, fix: 'Stores scan tools/list; with no tools there is nothing to list.' });
+        const ping = await client.request('ping').catch(() => null);
+        checks.push({
+            id: 'server.ping',
+            level: ping && ping.status < 300 && !ping.body?.error ? 'pass' : 'warn',
+            title: 'ping answers',
+            fix: 'Answer "ping" with an empty result; some clients use it for health checks.',
+        });
+        // OpenAI's scanner probes optional methods and treats a 500 / -32603 as a crash.
+        const probe = await client.request('server/discover').catch(() => null);
+        const code = probe?.body?.error?.code;
+        // Any other JSON-RPC error at HTTP 200 is survivable; a 5xx, -32603 or no JSON-RPC answer is not.
+        const survivable = probe?.status === 200 && typeof code === 'number' && code !== -32603;
+        checks.push(probe && probe.status === 200 && code === -32601
+            ? { id: 'server.unknown-method', level: 'pass', title: 'Unknown methods return -32601 (method not found)' }
+            : {
+                id: 'server.unknown-method',
+                level: survivable ? 'warn' : 'fail',
+                title: 'Unknown methods return -32601 (method not found)',
+                detail: `server/discover got HTTP ${probe?.status ?? 'error'}${code !== undefined ? `, code ${code}` : ''}`,
+                fix: "Return JSON-RPC error -32601 at HTTP 200 for methods you don't implement. OpenAI's tool scan probes server/discover and aborts on a 500 or -32603.",
+                stores: ['chatgpt'],
+            });
+        const note = await client.request('notifications/initialized', undefined, { notification: true }).catch(() => null);
+        checks.push({
+            id: 'server.notifications',
+            level: note && (note.status === 202 || note.status === 200 || note.status === 204) ? 'pass' : 'warn',
+            title: 'Notifications are accepted',
+            detail: note ? `HTTP ${note.status}` : 'no answer',
+            fix: 'Reply 202 Accepted to JSON-RPC notifications (messages with no id).',
+        });
+        const slash = await new McpClient(url.replace(/\/?$/, '/'), bearer).request('tools/list').catch(() => null);
+        checks.push({
+            id: 'server.trailing-slash',
+            level: slash && slash.status < 400 ? 'pass' : 'warn',
+            title: 'The URL with a trailing slash works too',
+            detail: slash ? `HTTP ${slash.status}` : 'no answer',
+            fix: 'Accept /mcp/ as well as /mcp. Reviewers paste URLs by hand, and a 404 reads as "unable to connect".',
+        });
+    }
+    // CORS preflight, as a browser-based connector would send it.
+    const pre = await fetch(url, {
+        method: 'OPTIONS',
+        headers: { origin: 'https://chatgpt.com', 'access-control-request-method': 'POST', 'access-control-request-headers': 'content-type, mcp-protocol-version, authorization' },
+        signal: AbortSignal.timeout(10_000),
+    }).catch(() => null);
+    const allow = pre?.headers.get('access-control-allow-origin');
+    checks.push({
+        id: 'server.cors',
+        level: pre && pre.status < 300 && allow ? 'pass' : 'warn',
+        title: 'CORS preflight answers',
+        detail: pre ? `HTTP ${pre.status}, allow-origin ${allow ?? 'missing'}` : 'no answer',
+        fix: 'Answer OPTIONS on the MCP endpoint with 204 and Access-Control-Allow-Origin/-Headers (content-type, mcp-protocol-version, mcp-session-id, authorization).',
+    });
+    // Filtering by user agent: a scanner and a browser should get the same status.
+    const asBrowser = await fetch(url, { method: 'POST', headers: { 'content-type': 'application/json', 'user-agent': BROWSER_UA }, body: '{"jsonrpc":"2.0","id":1,"method":"ping"}' }).catch(() => null);
+    const asBot = await fetch(url, { method: 'POST', headers: { 'content-type': 'application/json', 'user-agent': 'python-requests/2.32' }, body: '{"jsonrpc":"2.0","id":1,"method":"ping"}' }).catch(() => null);
+    if (asBrowser && asBot) {
+        const blocked = asBot.status === 403 && asBrowser.status !== 403;
+        checks.push({
+            id: 'server.bot-filter',
+            level: blocked ? 'fail' : asBot.status === 403 ? 'warn' : 'pass',
+            title: 'Automated clients are not blocked',
+            detail: `browser UA ${asBrowser.status}, script UA ${asBot.status}`,
+            fix: 'A firewall or bot rule is returning 403 to non-browser clients. Store scanners and reviewers are automated; allow them on the MCP path.',
+        });
+    }
+    checks.push(await tls12Check(url));
+    checks.push(await echCheck(url));
+    return { checks, tools };
+}
+/** Some review networks only speak TLS 1.2. */
+function tls12Check(url) {
+    const host = new URL(url).hostname;
+    return new Promise((resolve) => {
+        const sock = connect({ host, port: 443, servername: host, maxVersion: 'TLSv1.2', timeout: 8000 }, () => {
+            sock.end();
+            resolve({ id: 'server.tls12', level: 'pass', title: 'A TLS 1.2 client can connect' });
+        });
+        const bad = (why) => resolve({ id: 'server.tls12', level: 'warn', title: 'A TLS 1.2 client can connect', detail: why, fix: 'Allow TLS 1.2; some corporate and review proxies cannot do TLS 1.3.' });
+        sock.on('error', (e) => bad(e.message));
+        sock.on('timeout', () => {
+            sock.destroy();
+            bad('timed out');
+        });
+    });
+}
+/** Encrypted ClientHello in DNS makes TLS-inspecting proxies reset the connection. */
+async function echCheck(url) {
+    const host = new URL(url).hostname;
+    const res = await fetch(`https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(host)}&type=HTTPS`, { headers: { accept: 'application/dns-json' } }).catch(() => null);
+    const data = (await res?.json().catch(() => null));
+    const ech = (data?.Answer ?? []).some((a) => /\bech=/.test(a.data));
+    return ech
+        ? {
+            id: 'server.ech',
+            level: 'fail',
+            title: 'DNS does not advertise Encrypted ClientHello',
+            detail: `${host} has ech= in its HTTPS record`,
+            fix: "Turn ECH off for this domain (Cloudflare: PATCH zones/<id>/settings/ech {\"value\":\"off\"}; it's API-only on the free plan). TLS-inspecting review proxies reset ECH handshakes: three ChatGPT rejections traced back to this, with nothing in the server's logs.",
+            stores: ['chatgpt'],
+        }
+        : { id: 'server.ech', level: 'pass', title: 'DNS does not advertise Encrypted ClientHello' };
+}