mcplane 0.1.0 → 0.2.0

package/README.md

@@ -44,7 +44,7 @@ Cursor, VS Code and others: add a stdio server with command `npx` and args `["-y
 
 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`.
+Tools: `preflight`, `drift`, `pack`, `publish`, `record_submission`, `record_decision`, `submission_status`, `install_links`, `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
 
@@ -53,10 +53,11 @@ 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
+✓ Review Times             preflight clean · listed on mcp-registry, glama, chatgpt
+✗ Invoice Bot              2 blocking · waiting on claude-connectors · listed on mcp-registry
+✗ Weather Pro              1 store update needed · listed on mcp-registry, claude-connectors · 1 listing fix
+    chatgpt: Hints changed: send_alert
+    claude-connectors: listing doesn't show: forecast_hourly (ask the review team to resync)
 
 3 projects, 2 need attention.
 ```
@@ -67,13 +68,14 @@ npx mcplane fleet --root ~/Projects
 
 | 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 |
+| Official MCP Registry | **Publishes**: writes `server.json`, runs `mcp-publisher`, signs in with GitHub OIDC in Actions. Glama and PulseMCP import from it; GitHub's MCP gallery (VS Code) syncs it after a one-time manual onboarding | 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 |
+| awesome-remote-mcp-servers | The three-line entry with your Glama connector badge and auth marker, ready for the PR | |
 | 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 | |
 
@@ -83,14 +85,41 @@ npx mcplane fleet --root ~/Projects
 
 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.
+- **Server**: `initialize`, `tools/list` and `ping` work. An OAuth server that initializes without a token also lists its tools without one (the half-way state leaves a new ChatGPT connector stuck on "no actions available"). 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.
+- **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. Every test case uses tools the live server actually has. 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.
 
+Preflight also lists what no script can see and that has still cost real submissions. For example: a reviewer account a stranger can actually use (not your Google login, email already confirmed, no 2FA), and a safe target for write tools so reviewers don't post to a real timeline.
+
+## Where you're listed
+
+```sh
+mcplane listings
+```
+
+```
+✗ Official MCP Registry        listed
+    latest is v1.0.0, mcplane.json says v1.0.1
+✓ Glama                        listed  (Imported from the registry. Claim it with glama.json so the score badge is yours.)
+✗ Claude connectors            listed  (tier: community)
+    listing doesn't show: forecast_hourly (ask the review team to resync)
+· Cursor Marketplace           missing
+? ChatGPT                      unknown  (OpenAI's directory can't be read automatically. Open your plugin page and compare.)
+```
+
+A form that returned 200 is a claim; the public record is the result. `listings` reads every store with an open record and compares it with your live server and `mcplane.json`:
+- MCP Registry: versions, status, endpoint.
+- Claude: the connectors directory feed, including the tool inventory synced at submission, which you can't edit yourself; and the community plugin mirror.
+- Cursor and Grok.
+- Glama's registry import.
+- Both awesome lists and Docker's catalog.
+
+Coverage decays quietly, so run it on a schedule (`--ci` exits 1 on a mismatch). `fleet` runs it for every project.
+
 ## 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.
@@ -115,7 +144,7 @@ Like fastlane's lanes: named workflows in `mcplane.json`.
 }
 ```
 
-`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.
+`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`, `watch` and `release` are built in.
 
 ## CI
 
@@ -132,6 +161,21 @@ jobs:
           command: check   # preflight + drift --ci
 ```
 
+And weekly, to catch listings that went stale:
+
+```yaml
+on:
+  schedule: [{ cron: '0 9 * * 1' }]
+jobs:
+  listings:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: stevysmith/mcplane@v0
+        with:
+          command: watch   # listings --ci + drift --ci
+```
+
 Publishing to the MCP Registry from CI needs no secrets for `io.github.*` names:
 
 ```yaml
@@ -166,7 +210,7 @@ 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
+listings [--ci]               Where you're listed, and whether what went live matches
 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
@@ -186,7 +230,7 @@ One file describes your server and its listings. [`schema.json`](schema.json) gi
 |---|---|
 | `precheck` | `preflight` |
 | `deliver` + metadata in the repo | `mcplane.json`, `pack`, `publish` |
-| `download_metadata` | `pull` |
+| `download_metadata` | `listings`: reads what went live back and diffs it |
 | `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 |

package/dist/checks/listing.js

@@ -106,6 +106,15 @@ export async function listingChecks(m, tools, stores) {
     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', []);
+    // Test cases must name tools the server actually has; descriptions drift away from live servers.
+    const named = [...new Set((m.tests?.positive ?? []).flatMap((t) => t.tools))];
+    if (tools.length && named.length) {
+        const live = new Set(tools.map((t) => t.name));
+        const unknown = named.filter((n) => !live.has(n));
+        checks.push(unknown.length
+            ? { id: 'listing.test-tools', level: 'fail', title: 'Test cases use tools the server has', detail: unknown.join(', '), fix: 'Reviewers run your test cases against the live server. Update the tests, and check the description doesn’t promise tools you no longer expose.' }
+            : { id: 'listing.test-tools', level: 'pass', title: 'Test cases use tools the server has' });
+    }
     // ChatGPT domain verification
     if (has(stores, 'chatgpt')) {
         const ch = await get(`${origin}/.well-known/openai-apps-challenge`);

package/dist/checks/server.js

@@ -37,9 +37,28 @@ export async function serverChecks(url, auth, token) {
         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)) {
+    // An OAuth server that answers initialize without a token should list its tools the same way. One that
+    // initializes but then refuses tools/list leaves ChatGPT's new connector stuck on "no actions available":
+    // ChatGPT reads the list before signing in; Claude and Cursor sign in first, so they never show it.
+    if (auth === 'oauth' && !token && init.status < 300) {
+        const peek = await client.request('tools/list').catch(() => null);
+        const peekTools = (peek?.body?.result?.tools ?? []);
+        checks.push(peekTools.length
+            ? { id: 'server.public-tools', level: 'pass', title: 'tools/list answers without a token, like initialize' }
+            : {
+                id: 'server.public-tools',
+                level: 'warn',
+                title: 'tools/list answers without a token, like initialize',
+                detail: `initialize works unsigned, tools/list gave HTTP ${peek?.status ?? 'error'} with ${peekTools.length} tools`,
+                fix: 'Either return 401 for everything until sign-in, or list tools without a token and gate execution. The half-way state froze one team’s ChatGPT connector at "no actions available" until they deleted and recreated it.',
+                stores: ['chatgpt'],
+            });
+        if (peekTools.length)
+            tools = peekTools;
+    }
+    if (auth === 'none' || (token && init.status < 300) || tools.length) {
         const list = await client.request('tools/list').catch(() => null);
-        tools = list?.body?.result?.tools ?? [];
+        tools = list?.body?.result?.tools?.length ? list.body.result.tools : 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.' });

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { writeFile, access } from 'node:fs/promises';
 import { parseArgs } from 'node:util';
-import { MANIFEST_FILE, draftManifest, loadManifest } from './manifest.js';
+import { MANIFEST_FILE, draftManifest, loadManifest, storesOf } from './manifest.js';
 import { VERSION } from './version.js';
 import { preflight } from './preflight.js';
 import { printPreflight } from './report.js';
@@ -10,7 +10,8 @@ import { recordDecision, recordSubmitted, status } from './submissions.js';
 import { chatgptPack, claudePack, directoriesPack, simplePack, writePack } from './packs.js';
 import { drift, printDrift, takeSnapshot } from './drift.js';
 import { publish } from './publish.js';
-import { lanes, pull, runLane, tryLinks } from './extras.js';
+import { lanes, runLane, tryLinks } from './extras.js';
+import { listings, printListings } from './listings.js';
 import { fleet, fleetRun, printFleet } from './fleet.js';
 const HELP = `mcplane: fastlane for MCP servers
 
@@ -34,8 +35,8 @@ Usage
   mcplane baseline <store> [--version x.y.z]   Record a listing that's already live as the drift baseline
   mcplane publish <store> [--yes]     Publish where the store allows it (mcp-registry, grok); dry run without --yes
   mcplane try                         Install links for every client, for you and your testers
-  mcplane pull                        Compare your live public listings with mcplane.json
-  mcplane lanes                       List lanes; run one with "mcplane <lane>" (built in: check, release)
+  mcplane listings [--store <id>]...  Where you're listed, and whether what went live matches your server (--ci)
+  mcplane lanes                       List lanes; run one with "mcplane <lane>" (built in: check, watch, release)
   mcplane fleet [--root <dir>]        Every project under a folder: blockers, store updates needed, reviews waiting
       --quick                         Skip the live checks; just submissions
   mcplane fleet run <command...>      Run any mcplane command in every project (e.g. fleet run publish mcp-registry --yes)
@@ -215,7 +216,7 @@ async function main() {
             console.log(JSON.stringify(rows, null, 2));
         else
             printFleet(rows);
-        if (values.ci && rows.some((r) => r.error || r.blocking || r.driftActions?.length))
+        if (values.ci && rows.some((r) => r.error || r.blocking || r.driftActions?.length || r.listingIssues?.length))
             process.exitCode = 1;
         return;
     }
@@ -225,24 +226,16 @@ async function main() {
             console.log(`${t.client.padEnd(22)} ${t.how}`);
         return;
     }
-    if (cmd === 'pull') {
+    if (cmd === 'listings' || cmd === 'pull') {
         const m = await loadManifest();
-        const diffs = await pull(m);
-        if (values.json) {
-            console.log(JSON.stringify(diffs, null, 2));
-            return;
-        }
-        for (const d of diffs) {
-            if (!d.found)
-                console.log(`${d.store}: not listed yet.`);
-            else if (!d.fields.length)
-                console.log(`${d.store}: matches mcplane.json.`);
-            else {
-                console.log(`${d.store}: live listing differs${d.url ? ` (${d.url})` : ''}`);
-                for (const f of d.fields)
-                    console.log(`  ${f.field}\n    live:  ${f.live.slice(0, 160)}\n    yours: ${f.yours.slice(0, 160)}`);
-            }
-        }
+        const stores = (values.store?.length ? values.store : storesOf(m));
+        const rows = await listings(m, stores, { token: values.token ?? process.env.MCPLANE_TOKEN });
+        if (values.json)
+            console.log(JSON.stringify(rows, null, 2));
+        else
+            printListings(rows);
+        if (values.ci && rows.some((r) => r.issues.length))
+            process.exitCode = 1;
         return;
     }
     const m = await loadManifest().catch(() => null);

package/dist/extras.js

@@ -2,14 +2,14 @@
  * The fastlane ideas, for agent-era stores:
  *   lanes  named workflows in mcplane.json ("mcplane release")
  *   try    install links for every client, like pilot for TestFlight testers
- *   pull   read your live public listings back and compare with mcplane.json,
- *          like deliver's download_metadata
  */
 import { spawnSync } from 'node:child_process';
 /* ---------------- lanes ---------------- */
 export const DEFAULT_LANES = {
     // Fast checks for CI on every push or deploy.
     check: ['preflight', 'drift --ci'],
+    // On a schedule: listings that went stale or never appeared.
+    watch: ['listings --ci', 'drift --ci'],
     // Everything for a release: checks, packs, the stores that can be automated, then your hand-offs.
     release: [
         'preflight',
@@ -68,42 +68,3 @@ export function tryLinks(m) {
         { client: 'ChatGPT', how: `Turn on developer mode (Settings → Apps → Advanced), then Plugins → Add → Create MCP App → ${url}${m.server.auth === 'oauth' ? ' (OAuth)' : ' (No authentication)'}` },
     ];
 }
-const norm = (s) => (s ?? '').replace(/\s+/g, ' ').trim();
-const sameUrl = (a, b) => !!a && !!b && a.replace(/\/+$/, '').replace(/\.git$/, '').toLowerCase() === b.replace(/\/+$/, '').replace(/\.git$/, '').toLowerCase();
-/** Reads the public listings that have an open feed and compares them with mcplane.json. */
-export async function pull(m) {
-    const out = [];
-    // Claude connectors: Anthropic's public directory feed.
-    const res = await fetch('https://api.anthropic.com/api/directory/servers?verified_tier=anthropic,partner,community&visibility=commercial&limit=5000', { headers: { 'user-agent': 'mcplane' } }).catch(() => null);
-    const data = res?.ok ? (await res.json().catch(() => null)) : null;
-    const hit = data?.servers?.find((s) => sameUrl(s.remote?.url, m.server.url));
-    out.push({
-        store: 'Claude connectors',
-        found: !!hit,
-        url: hit?.directory_url,
-        fields: hit
-            ? [
-                ['name', hit.display_name ?? hit.name, m.title],
-                ['one-liner', hit.one_liner, m.oneLiner],
-                ['description', hit.description, m.description],
-            ]
-                .filter(([, live, yours]) => norm(live) && norm(yours) && norm(live) !== norm(yours))
-                .map(([field, live, yours]) => ({ field, live: norm(live), yours: norm(yours) }))
-            : [],
-    });
-    // Cursor: the marketplace page embeds every approved plugin.
-    if (m.repository) {
-        const page = await fetch('https://cursor.com/marketplace', { headers: { 'user-agent': 'mcplane' } }).then((r) => r.text()).catch(() => '');
-        const html = page.replace(/\\"/g, '"');
-        const repo = m.repository.replace(/\.git$/, '').replace(/\/+$/, '');
-        const i = html.toLowerCase().indexOf(`"repositoryurl":"${repo.toLowerCase()}`);
-        const around = i >= 0 ? html.slice(Math.max(0, i - 3000), i) : '';
-        const desc = around.match(/"description":"((?:[^"\\]|\\.)*)"[^{]*$/)?.[1];
-        out.push({
-            store: 'Cursor',
-            found: i >= 0,
-            fields: desc && norm(desc) !== norm(m.oneLiner ?? m.description) ? [{ field: 'description', live: norm(desc), yours: norm(m.oneLiner ?? m.description) }] : [],
-        });
-    }
-    return out;
-}

package/dist/fleet.js

@@ -7,10 +7,11 @@ import { spawnSync } from 'node:child_process';
 import { readdir } from 'node:fs/promises';
 import { join, relative, resolve } from 'node:path';
 import { drift } from './drift.js';
+import { listings } from './listings.js';
 import { MANIFEST_FILE, loadManifest, storesOf } from './manifest.js';
 import { preflight } from './preflight.js';
 import { load } from './submissions.js';
-const SKIP = new Set(['node_modules', '.git', 'dist', 'build', '.mcplane', '.next', '.wrangler', 'vendor', 'target']);
+const SKIP = new Set(['node_modules', '.git', 'dist', 'build', '.mcplane', '.next', '.wrangler', 'vendor', 'target', 'examples', 'fixtures', 'test', 'tests']);
 /** Folders under root that hold an mcplane.json, depth-first, a few levels down. */
 export async function findProjects(root = process.cwd(), depth = 3) {
     const found = [];
@@ -47,7 +48,7 @@ async function pool(items, n, fn) {
     }));
     return out;
 }
-/** Preflight, drift and submissions for every project under root. Checks run four projects at a time. */
+/** Preflight, drift, listings and submissions for every project under root. Checks run four projects at a time. */
 export async function fleet(root = process.cwd(), opts = {}) {
     const projects = await findProjects(root);
     return pool(projects, 4, async (p) => {
@@ -69,6 +70,9 @@ export async function fleet(root = process.cwd(), opts = {}) {
             const d = await drift(p.manifest, storesOf(p.manifest), { token: opts.token }, p.dir);
             row.driftActions = d.items.filter((i) => i.level === 'action').map((i) => ({ store: i.store, what: i.what }));
             row.noSnapshot = d.missing;
+            const l = await listings(p.manifest, storesOf(p.manifest), { token: opts.token });
+            row.listedOn = l.filter((x) => x.state === 'listed').map((x) => x.store);
+            row.listingIssues = l.flatMap((x) => x.issues.map((issue) => ({ store: x.store, issue })));
         }
         catch (e) {
             row.error = e.message;
@@ -87,14 +91,17 @@ export function printFleet(rows) {
             r.toReview ? `${r.toReview} to review` : '',
             r.driftActions?.length ? `${r.driftActions.length} store update${r.driftActions.length === 1 ? '' : 's'} needed` : '',
             r.waiting.length ? `waiting on ${r.waiting.map((w) => w.store).join(', ')}` : '',
-            r.live.length ? `live on ${r.live.join(', ')}` : '',
+            r.listedOn ? `listed on ${r.listedOn.length ? r.listedOn.join(', ') : 'nothing yet'}` : r.live.length ? `live on ${r.live.join(', ')}` : '',
+            r.listingIssues?.length ? `${r.listingIssues.length} listing fix${r.listingIssues.length === 1 ? '' : 'es'}` : '',
         ].filter(Boolean);
-        const mark = r.error || r.blocking || r.driftActions?.length ? '✗' : '✓';
+        const mark = r.error || r.blocking || r.driftActions?.length || r.listingIssues?.length ? '✗' : '✓';
         console.log(`${mark} ${(r.name ?? r.project).padEnd(24)} ${bits.join(' · ')}`);
         for (const a of r.driftActions ?? [])
             console.log(`    ${a.store}: ${a.what}`);
+        for (const a of r.listingIssues ?? [])
+            console.log(`    ${a.store}: ${a.issue}`);
     }
-    const bad = rows.filter((r) => r.error || r.blocking || r.driftActions?.length).length;
+    const bad = rows.filter((r) => r.error || r.blocking || r.driftActions?.length || r.listingIssues?.length).length;
     console.log(`\n${rows.length} project${rows.length === 1 ? '' : 's'}, ${bad} need${bad === 1 ? 's' : ''} attention. Details: cd into one and run "mcplane preflight" or "mcplane drift".`);
 }
 /** Runs one mcplane command in every project, one after another. */

package/dist/listings.js

@@ -0,0 +1,169 @@
+/**
+ * Where you're listed, and whether what went live matches. Every store with an
+ * open record is read directly; a save that returned 200 is a claim, the
+ * public record is the result. Coverage decays quietly, so this is meant to
+ * run on a schedule.
+ */
+import { liveTools, repoHead } from './drift.js';
+import { registryName } from './publish.js';
+import { STORE_NAMES } from './types.js';
+const UA = { 'user-agent': 'mcplane' };
+/** Public feeds are sometimes slow (the registry has taken 40s); one retry with a longer wait. */
+const getJson = async (url) => {
+    for (const wait of [15_000, 45_000]) {
+        const r = await fetch(url, { headers: UA, signal: AbortSignal.timeout(wait) }).catch(() => null);
+        if (r?.ok)
+            return (await r.json().catch(() => null));
+    }
+    return null;
+};
+const getText = async (url) => {
+    const r = await fetch(url, { headers: UA, signal: AbortSignal.timeout(20_000) }).catch(() => null);
+    return r?.ok ? r.text() : null;
+};
+const status = async (url) => (await fetch(url, { headers: UA, redirect: 'follow', signal: AbortSignal.timeout(20_000) }).catch(() => null))?.status ?? 0;
+const norm = (s) => (s ?? '').replace(/\s+/g, ' ').trim();
+const bare = (u) => (u ?? '').replace(/\/+$/, '').replace(/\.git$/, '').toLowerCase();
+async function registry(m) {
+    const name = registryName(m);
+    const data = await getJson(`https://registry.modelcontextprotocol.io/v0/servers?search=${encodeURIComponent(name)}`);
+    if (!data)
+        return { store: 'mcp-registry', state: 'unknown', issues: [], note: 'Registry API did not answer.' };
+    const mine = (data.servers ?? []).filter((x) => x.server.name === name);
+    if (!mine.length)
+        return { store: 'mcp-registry', state: 'missing', issues: [], note: `No ${name} in the registry. "mcplane publish mcp-registry".` };
+    const latest = mine.find((x) => x._meta?.['io.modelcontextprotocol.registry/official']?.isLatest) ?? mine[mine.length - 1];
+    const issues = [];
+    const st = latest._meta?.['io.modelcontextprotocol.registry/official']?.status;
+    if (st && st !== 'active')
+        issues.push(`latest version is ${st}`);
+    if (m.version && latest.server.version !== m.version)
+        issues.push(`latest is v${latest.server.version}, mcplane.json says v${m.version}`);
+    if (!latest.server.remotes?.some((r) => bare(r.url) === bare(m.server.url)))
+        issues.push(`endpoint differs: ${latest.server.remotes?.map((r) => r.url).join(', ') || 'none'}`);
+    return { store: 'mcp-registry', state: 'listed', url: `https://registry.modelcontextprotocol.io/v0/servers?search=${encodeURIComponent(name)}`, issues };
+}
+async function claudeConnectors(m, token) {
+    const data = await getJson('https://api.anthropic.com/api/directory/servers?verified_tier=anthropic,partner,community&visibility=commercial&limit=5000');
+    if (!data)
+        return { store: 'claude-connectors', state: 'unknown', issues: [], note: 'Anthropic’s directory feed did not answer.' };
+    const hit = data.servers?.find((s) => bare(s.remote?.url ?? s.url) === bare(m.server.url) || norm(s.name).toLowerCase() === norm(m.title).toLowerCase());
+    if (!hit)
+        return { store: 'claude-connectors', state: 'missing', issues: [] };
+    const issues = [];
+    if (m.oneLiner && norm(hit.one_liner) !== norm(m.oneLiner))
+        issues.push('one-liner differs from mcplane.json');
+    if (m.description && norm(hit.description) !== norm(m.description))
+        issues.push('description differs from mcplane.json');
+    // The tool list is synced from your server at submission and isn't an editable field: compare it with what you serve now.
+    const published = hit.tool_names ?? [];
+    const live = (await liveTools(m, token).catch(() => [])).map((t) => t.name);
+    if (live.length && published.length) {
+        const missing = live.filter((n) => !published.includes(n));
+        const gone = published.filter((n) => !live.includes(n));
+        if (missing.length)
+            issues.push(`listing doesn't show: ${missing.join(', ')} (ask the review team to resync)`);
+        if (gone.length)
+            issues.push(`listing still shows removed tools: ${gone.join(', ')}`);
+    }
+    const tier = hit.verified_tier ?? hit.tier;
+    return { store: 'claude-connectors', state: 'listed', url: hit.directory_url ?? `https://claude.ai/directory/${hit.id}`, issues, note: tier ? `tier: ${tier}` : undefined };
+}
+async function claudePlugins(m, head) {
+    if (!m.repository)
+        return { store: 'claude-plugins', state: 'unknown', issues: [], note: 'No repository in mcplane.json.' };
+    const data = await getJson('https://raw.githubusercontent.com/anthropics/claude-plugins-community/main/.claude-plugin/marketplace.json');
+    if (!data)
+        return { store: 'claude-plugins', state: 'unknown', issues: [] };
+    const hit = data.plugins?.find((p) => bare(p.source?.url) === bare(m.repository));
+    if (!hit)
+        return { store: 'claude-plugins', state: 'missing', issues: [], note: 'Not in the community marketplace mirror (synced nightly from Anthropic’s review).' };
+    const issues = head && hit.source?.sha && hit.source.sha !== head ? [`serves ${hit.source.sha.slice(0, 7)}, your repo is at ${head.slice(0, 7)}`] : [];
+    return { store: 'claude-plugins', state: 'listed', issues, note: `as "${hit.name}"` };
+}
+async function cursor(m) {
+    if (!m.repository)
+        return { store: 'cursor', state: 'unknown', issues: [], note: 'No repository in mcplane.json.' };
+    const page = await getText('https://cursor.com/marketplace');
+    if (!page)
+        return { store: 'cursor', state: 'unknown', issues: [] };
+    const html = page.replace(/\\"/g, '"').toLowerCase();
+    const found = html.includes(`"repositoryurl":"${bare(m.repository)}`);
+    return { store: 'cursor', state: found ? 'listed' : 'missing', issues: [] };
+}
+async function grok(m, head) {
+    const data = await getJson('https://raw.githubusercontent.com/xai-org/plugin-marketplace/main/.grok-plugin/marketplace.json');
+    if (!data)
+        return { store: 'grok', state: 'unknown', issues: [] };
+    const hit = data.plugins?.find((p) => p.name === m.name || (m.repository && bare(p.source?.url) === bare(m.repository)));
+    if (!hit)
+        return { store: 'grok', state: 'missing', issues: [] };
+    const issues = head && hit.source?.sha && hit.source.sha !== head ? [`pinned to ${hit.source.sha.slice(0, 7)}, your repo is at ${head.slice(0, 7)}`] : [];
+    return { store: 'grok', state: 'listed', issues };
+}
+async function glama(m) {
+    const url = `https://glama.ai/mcp/connectors/${registryName(m)}`;
+    const code = await status(url);
+    if (code === 200)
+        return { store: 'glama', state: 'listed', url, issues: [], note: 'Imported from the registry. Claim it with glama.json so the score badge is yours.' };
+    if (code === 404)
+        return { store: 'glama', state: 'missing', issues: [], note: 'Glama imports connectors from the official registry; publish there first.' };
+    return { store: 'glama', state: 'unknown', issues: [] };
+}
+async function awesome(m, store, repo) {
+    const readme = await getText(`https://raw.githubusercontent.com/${repo}/main/README.md`);
+    if (!readme)
+        return { store, state: 'unknown', issues: [] };
+    const text = readme.toLowerCase();
+    const keys = [m.server.url, m.repository, m.links?.website].filter(Boolean).map((u) => bare(u));
+    return { store, state: keys.some((k) => text.includes(k)) ? 'listed' : 'missing', issues: [] };
+}
+async function docker(m) {
+    const code = await status(`https://github.com/docker/mcp-registry/tree/main/servers/${m.name}`);
+    return { store: 'docker', state: code === 200 ? 'listed' : code === 404 ? 'missing' : 'unknown', issues: [] };
+}
+export function printListings(rows) {
+    const mark = { listed: '✓', missing: '·', unknown: '?' };
+    for (const r of rows) {
+        const flag = r.state === 'listed' && r.issues.length ? '✗' : mark[r.state];
+        console.log(`${flag} ${STORE_NAMES[r.store].padEnd(28)} ${r.state}${r.note ? `  (${r.note})` : ''}`);
+        if (r.url && r.state === 'listed')
+            console.log(`    ${r.url}`);
+        for (const i of r.issues)
+            console.log(`    ${i}`);
+    }
+    const listed = rows.filter((r) => r.state === 'listed');
+    console.log(`\nListed on ${listed.length} of ${rows.length}; ${listed.filter((r) => r.issues.length).length} need a fix. ? means no public record to read.`);
+}
+const MANUAL = {
+    chatgpt: 'OpenAI’s directory can’t be read automatically. Open your plugin page and compare.',
+    muse: 'Meta publishes no directory feed yet.',
+    smithery: 'Check smithery.ai; its public "verified" flag can lag behind passed proofs.',
+    cline: 'Cline’s marketplace has no public feed; watch your submission issue.',
+    lobehub: 'Check market.lobehub.com.',
+};
+export async function listings(m, stores, opts = {}) {
+    const head = await repoHead(m.repository);
+    const jobs = stores.map((s) => {
+        if (s === 'mcp-registry')
+            return registry(m);
+        if (s === 'claude-connectors')
+            return claudeConnectors(m, opts.token);
+        if (s === 'claude-plugins')
+            return claudePlugins(m, head);
+        if (s === 'cursor')
+            return cursor(m);
+        if (s === 'grok')
+            return grok(m, head);
+        if (s === 'glama')
+            return glama(m);
+        if (s === 'awesome-mcp-servers')
+            return awesome(m, s, 'punkpeye/awesome-mcp-servers');
+        if (s === 'awesome-remote-mcp-servers')
+            return awesome(m, s, 'punkpeye/awesome-remote-mcp-servers');
+        if (s === 'docker')
+            return docker(m);
+        return Promise.resolve({ store: s, state: 'unknown', issues: [], note: MANUAL[s] });
+    });
+    return Promise.all(jobs);
+}

package/dist/mcp-server.js

@@ -11,7 +11,8 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod';
 import { drift } from './drift.js';
 import { fleet } from './fleet.js';
-import { pull, tryLinks } from './extras.js';
+import { tryLinks } from './extras.js';
+import { listings } from './listings.js';
 import { MANIFEST_FILE, draftManifest, loadManifest, storesOf } from './manifest.js';
 import { chatgptPack, claudePack, directoriesPack, simplePack, writePack } from './packs.js';
 import { preflight } from './preflight.js';
@@ -110,12 +111,16 @@ export async function serve() {
         inputSchema: { project: PROJECT },
         annotations: { title: 'Try', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     }, async ({ project }) => reply({ links: tryLinks(await loadManifest(dirOf(project))) }));
-    server.registerTool('pull_listings', {
-        title: 'Compare live listings with mcplane.json',
-        description: 'Reads the store listings that have an open feed (Claude directory, Cursor marketplace) and returns fields that differ from mcplane.json.',
-        inputSchema: { project: PROJECT },
-        annotations: { title: 'Pull', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    }, async ({ project }) => reply({ listings: await pull(await loadManifest(dirOf(project))) }));
+    server.registerTool('listings', {
+        title: 'Where you’re listed, and whether it matches',
+        description: 'Reads every store with a public record (MCP Registry, Claude connectors and plugins, Cursor, Grok, Glama, the awesome lists, Docker) and returns, per store: listed, missing or unknown, plus differences from your live server and mcplane.json, such as tools missing from Claude’s synced inventory or a plugin pinned to an old commit.',
+        inputSchema: { project: PROJECT, stores: z.array(STORE).optional() },
+        annotations: { title: 'Listings', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ project, stores }) => {
+        const m = await loadManifest(dirOf(project));
+        const rows = await listings(m, stores?.length ? stores : storesOf(m), { token: token() });
+        return reply({ listings: rows }, `Listed on ${rows.filter((r) => r.state === 'listed').length} of ${rows.length}; ${rows.filter((r) => r.issues.length).length} need a fix.`);
+    });
     server.registerTool('init', {
         title: 'Create mcplane.json',
         description: 'Writes a starting mcplane.json from what the live server and its domain reveal (name, auth, privacy, support, terms and icon URLs). Refuses to overwrite an existing file.',
@@ -131,12 +136,12 @@ export async function serve() {
     });
     server.registerTool('fleet', {
         title: 'Every project at a glance',
-        description: 'Finds every mcplane.json under a folder (three levels down) and returns, per project: blocking preflight checks, store updates needed since the last submission, reviews waiting and stores it is live on. quick true skips the live checks.',
+        description: 'Finds every mcplane.json under a folder (three levels down) and returns, per project: blocking preflight checks, store updates needed since the last submission, reviews waiting, where it is listed and listings that no longer match. quick true skips the live checks.',
         inputSchema: { root: z.string().optional().describe('Folder to search. Defaults to where mcplane was started.'), quick: z.boolean().default(false) },
         annotations: { title: 'Fleet', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async ({ root, quick }) => {
         const rows = await fleet(dirOf(root), { checks: !quick, token: token() });
-        const bad = rows.filter((r) => r.error || r.blocking || r.driftActions?.length).length;
+        const bad = rows.filter((r) => r.error || r.blocking || r.driftActions?.length || r.listingIssues?.length).length;
         return reply({ projects: rows }, `${rows.length} projects, ${bad} need attention.`);
     });
     // Prompts are the agent-era "fastlane init": the agent in your repo writes the listing, you approve it.

package/dist/packs.js

@@ -237,9 +237,9 @@ export function directoriesPack(m) {
     const repo = m.repository?.replace(/\.git$/, '');
     const desc = m.oneLiner ?? m.description ?? m.title;
     const rows = [
-        ['MCP.Directory', 'https://mcp.directory/submit', 'Reads the official registry; claim the listing there, or submit a GitHub URL (reviewed within a day).'],
-        ['mcp.so', 'https://mcp.so/submit', 'Repo URL and name. Paid option skips review. No update mechanism: edit by hand.'],
-        ['MCP Market', 'https://mcpmarket.com/submit', 'GitHub URL, email, type. The free queue runs to weeks; paid lists within a day.'],
+        ['MCP.Directory', 'https://mcp.directory/submit', 'Says it auto-discovers from the official registry; its form wants a GitHub repo first, so hosted servers without public code can stall.'],
+        ['mcp.so', 'https://mcp.so/submit', 'Repo URL and name. Edits can return HTTP 200 with a hidden validation error (a tagline that is too long): check the public page after saving.'],
+        ['MCP Market', 'https://mcpmarket.com/submit', 'GitHub URL, email, type. The free queue runs to weeks; paid lists within a day. Check where its Try Now button sends people.'],
         ['mcpservers.org', 'https://mcpservers.org/submit', 'Has a field for your Official MCP Registry name. Free takes about two weeks.'],
         ['cursor.directory', 'https://cursor.directory', 'Submit from its MCP section.'],
     ];
@@ -260,6 +260,8 @@ Values to paste:
 |---|---|---|
 ${rows.map((r) => `| ${r[0]} | ${r[1]} | ${r[2]} |`).join('\n')}
 
+After any form: a save that returned 200 is a claim. Open the public page and check the endpoint, auth and every link.
+
 Directories send little traffic on their own; the registry, the big stores and your own docs matter more. Do these once, and don't pay to skip a queue unless a launch date depends on it.
 `;
     return { files: [{ path: 'directories.md', content: md }], problems: [], todo: [] };

package/dist/preflight.js

@@ -7,9 +7,12 @@ import { storesOf } from './manifest.js';
 function reminders(m, stores) {
     const r = [];
     if (m.server.auth === 'oauth') {
-        r.push('Give reviewers a demo account: email and password, no 2FA, SMS or email confirmation, seeded with data that matches every test case. Re-check the seed right before submitting.');
+        r.push('Give reviewers a demo account a stranger can use: email and password (not your Google or SSO login), email already confirmed, no 2FA or SMS, seeded with data for every test case. Re-check the seed right before submitting.');
         r.push('Sign in through your OAuth flow once as a brand-new user. A blank post-sign-in redirect stranded a ChatGPT reviewer between registration and consent.');
     }
+    if (stores.some((s) => s === 'chatgpt' || s === 'claude-connectors')) {
+        r.push('If a tool writes somewhere public (posts, sends, publishes), give reviewers a safe target: a sandbox account or a "playground" option that validates and then discards. Reviewers test writes; they shouldn’t post to a real timeline.');
+    }
     if (stores.includes('chatgpt')) {
         r.push('ChatGPT needs a demo video recorded in developer mode that shows the tools your test cases use. Re-record it whenever tools change.');
         r.push('After "Submit for Review" the ChatGPT portal shows nothing for about 20 seconds. Confirm the status on the plugins list, not the button.');
@@ -17,6 +20,8 @@ function reminders(m, stores) {
         r.push('ChatGPT allows one version in review at a time. To change a submission, Cancel Review and resubmit the same draft.');
     }
     if (stores.includes('claude-connectors') || stores.includes('claude-plugins')) {
+        if (stores.includes('claude-connectors'))
+            r.push('Claude connectors are submitted from an organisation’s admin settings (claude.ai/directory/manage), so you need admin rights in a paid org. The tool list is synced from your server when you submit; it is not an editable field.');
         if (stores.includes('claude-plugins'))
             r.push('Run "claude plugin validate --strict" in the plugin repo; the portal validates every commit on the branch it tracks.');
         r.push('Claude: "Passed review" is not the same as listed. Check claude.ai/directory for your listing after approval; with the new portal you choose when to publish.');

package/dist/publish.js

@@ -59,7 +59,7 @@ async function registryVersions(name) {
 }
 /** 1.2.0 → 1.2.0-1, 1.2.0-1 → 1.2.0-2: the registry's way to change metadata without a new release. */
 const nextPrerelease = (v) => (/-(\d+)$/.test(v) ? v.replace(/-(\d+)$/, (_, n) => `-${Number(n) + 1}`) : `${v}-1`);
-const REGISTRY_READERS = 'GitHub’s MCP Registry (and VS Code), PulseMCP and MCP.Directory read from the official registry, so they pick this up on their own.';
+const REGISTRY_READERS = 'Glama and PulseMCP import from the official registry. GitHub’s MCP gallery (VS Code) needs a one-time manual onboarding, then syncs new versions. Run "mcplane listings" in a day or two to see where it landed.';
 async function publishRegistry(m, yes, dir) {
     const json = serverJson(m);
     const file = m.registry?.file ?? 'server.json';
@@ -201,6 +201,22 @@ async function publishGrok(m, yes) {
 function prepared(m, store) {
     const gh = ghRepo(m);
     const desc = m.oneLiner ?? m.subtitle ?? m.title;
+    if (store === 'awesome-remote-mcp-servers') {
+        const auth = m.server.auth === 'oauth' ? '🔐' : '🔓';
+        const reg = registryName(m);
+        const sentence = (desc.endsWith('.') ? desc : `${desc}.`).slice(0, 120);
+        return {
+            store,
+            done: false,
+            lines: [
+                'For hosted servers. Add this under the right category in punkpeye/awesome-remote-mcp-servers README.md (alphabetical):',
+                `- [${m.title}](${m.links?.website ?? m.server.url}) \`${m.server.url}\``,
+                `  [![${m.title} MCP connector](https://glama.ai/mcp/connectors/${reg}/badges/score.svg)](https://glama.ai/mcp/connectors/${reg})`,
+                `  ${auth} - ${sentence}`,
+                'Star the repo first (PRs from accounts that haven’t aren’t merged). CI sends an unauthenticated initialize: a 401 with WWW-Authenticate passes as OAuth. The Glama connector must exist ("mcplane listings"). Agent-opened PRs can end the title with 🤖🤖🤖 for the fast track.',
+            ],
+        };
+    }
     if (store === 'awesome-mcp-servers') {
         const link = gh ? `[${gh.owner}/${gh.repo}](https://github.com/${gh.owner}/${gh.repo})` : `[${m.title}](${m.links?.website ?? m.server.url})`;
         return {
@@ -222,10 +238,11 @@ function prepared(m, store) {
             store,
             done: false,
             lines: [
-                `Add ${gh ? `https://github.com/${gh.owner}/${gh.repo}` : 'your GitHub repo'} at https://glama.ai/mcp/servers ("Add MCP Server"). Glama runs its own checks (license, security, health) and scores the server.`,
-                'To claim the listing, commit glama.json at the repo root:',
+                `Hosted servers: Glama imports a connector from the official registry at https://glama.ai/mcp/connectors/${registryName(m)}. Publish there first, then claim it.`,
+                `Code on GitHub: add ${gh ? `https://github.com/${gh.owner}/${gh.repo}` : 'the repo'} at https://glama.ai/mcp/servers ("Add MCP Server"); Glama checks license, security and health, and scores it.`,
+                'To claim either, commit glama.json at the repo root:',
                 JSON.stringify({ $schema: 'https://glama.ai/mcp/schemas/server.json', maintainers: [owner] }, null, 2),
-                'awesome-mcp-servers asks for the Glama score badge on each entry, so do this first.',
+                'Both awesome lists require the Glama badge on each entry, so do this first.',
             ],
         };
     }

package/dist/types.js

@@ -12,4 +12,5 @@ export const STORE_NAMES = {
     cline: 'Cline MCP Marketplace',
     lobehub: 'LobeHub Market',
     'awesome-mcp-servers': 'awesome-mcp-servers',
+    'awesome-remote-mcp-servers': 'awesome-remote-mcp-servers',
 };

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.0';
+export const VERSION = '0.2.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcplane",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "fastlane for MCP servers: preflight against every store's rejection causes, publish where you can, prepare the rest, track every review.",
   "type": "module",
   "bin": {

package/schema.json

@@ -25,7 +25,8 @@
         "glama",
         "cline",
         "lobehub",
-        "awesome-mcp-servers"
+        "awesome-mcp-servers",
+        "awesome-remote-mcp-servers"
       ]
     },
     "url": {