mcplane 0.1.0 → 0.3.0

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.d.ts

@@ -0,0 +1,40 @@
+import type { Manifest, StoreId } from './types.js';
+export interface Project {
+    dir: string;
+    path: string;
+    manifest?: Manifest;
+    error?: string;
+}
+/** Folders under root that hold an mcplane.json, depth-first, a few levels down. */
+export declare function findProjects(root?: string, depth?: number): Promise<Project[]>;
+export interface FleetRow {
+    project: string;
+    name?: string;
+    url?: string;
+    blocking?: number;
+    toReview?: number;
+    driftActions?: {
+        store: StoreId;
+        what: string;
+    }[];
+    noSnapshot?: StoreId[];
+    waiting: {
+        store: StoreId;
+        since: string;
+    }[];
+    live: StoreId[];
+    listedOn?: StoreId[];
+    listingIssues?: {
+        store: StoreId;
+        issue: string;
+    }[];
+    error?: string;
+}
+/** Preflight, drift, listings and submissions for every project under root. Checks run four projects at a time. */
+export declare function fleet(root?: string, opts?: {
+    checks?: boolean;
+    token?: string;
+}): Promise<FleetRow[]>;
+export declare function printFleet(rows: FleetRow[]): void;
+/** Runs one mcplane command in every project, one after another. */
+export declare function fleetRun(root: string, args: string[]): Promise<number>;

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.d.ts

@@ -0,0 +1,13 @@
+import { type Manifest, type StoreId } from './types.js';
+export interface Listing {
+    store: StoreId;
+    state: 'listed' | 'missing' | 'unknown';
+    url?: string;
+    /** Differences between the live record and your server or mcplane.json. */
+    issues: string[];
+    note?: string;
+}
+export declare function printListings(rows: Listing[]): void;
+export declare function listings(m: Manifest, stores: StoreId[], opts?: {
+    token?: string;
+}): Promise<Listing[]>;

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/manifest.d.ts

@@ -0,0 +1,10 @@
+import { type Manifest } from './types.js';
+export { draftManifest, storesOf } from './draft.js';
+export declare const MANIFEST_FILE = "mcplane.json";
+export { SCHEMA_URL } from './draft.js';
+export declare function loadManifest(dir?: string): Promise<Manifest>;
+/**
+ * Creates .mcplane with its own .gitignore: snapshots are committed (CI reads
+ * them for drift), while submissions (private Review Times tokens) and packs stay local.
+ */
+export declare function ensureLocalDir(dir?: string): Promise<string>;

package/dist/manifest.js

@@ -1,9 +1,9 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
-import { McpClient } from './mcp-client.js';
 import { STORE_NAMES } from './types.js';
+export { draftManifest, storesOf } from './draft.js';
 export const MANIFEST_FILE = 'mcplane.json';
-export const SCHEMA_URL = 'https://unpkg.com/mcplane/schema.json';
+export { SCHEMA_URL } from './draft.js';
 export async function loadManifest(dir = process.cwd()) {
     const path = resolve(dir, MANIFEST_FILE);
     let raw;
@@ -44,54 +44,3 @@ export async function ensureLocalDir(dir = process.cwd()) {
     await writeFile(resolve(d, '.gitignore'), 'submissions.json\npacks/\n', { flag: 'wx' }).catch(() => null);
     return d;
 }
-export function storesOf(m) {
-    return m.stores?.length ? m.stores : Object.keys(STORE_NAMES);
-}
-/** A starting manifest from what the live server and its domain reveal. */
-export async function draftManifest(url) {
-    const client = new McpClient(url);
-    const init = await client.initialize().catch(() => null);
-    const auth = init?.status === 401 ? 'oauth' : 'none';
-    const info = init?.body?.result?.serverInfo ?? {};
-    const host = new URL(url).hostname;
-    const labels = host.split('.');
-    // api.example.com and mcp.example.com usually keep their pages on example.com.
-    const origins = [`https://${host}`, ...(labels.length > 2 ? [`https://${labels.slice(1).join('.')}`] : [])];
-    const origin = origins[origins.length - 1];
-    const found = async (p) => {
-        for (const o of origins) {
-            const r = await fetch(o + p, { method: 'GET', redirect: 'follow' }).catch(() => null);
-            if (r?.ok && !(r.headers.get('content-type') ?? '').includes('json'))
-                return o + p;
-        }
-        return undefined;
-    };
-    const first = async (...paths) => {
-        for (const p of paths) {
-            const hit = await found(p);
-            if (hit)
-                return hit;
-        }
-        return undefined;
-    };
-    const [privacy, support, terms, docs, icon] = await Promise.all([
-        first('/privacy', '/privacy-policy', '/legal/privacy'),
-        first('/support', '/contact', '/help'),
-        first('/terms', '/terms-of-service', '/legal/terms'),
-        first('/llms.txt', '/docs'),
-        first('/icon-512.png', '/icon.png', '/apple-touch-icon.png'),
-    ]);
-    return {
-        $schema: SCHEMA_URL,
-        name: String(info.name ?? new URL(url).hostname.split('.')[0]),
-        title: String(info.title ?? info.name ?? ''),
-        subtitle: '',
-        oneLiner: '',
-        description: '',
-        server: { url, auth },
-        author: { name: '', url: origin },
-        links: { website: origin, support, privacy, terms, docs },
-        icon,
-        stores: ['mcp-registry', 'chatgpt', 'claude-connectors', 'cursor', 'muse'],
-    };
-}

package/dist/mcp-client.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Just enough of a streamable-HTTP MCP client to inspect a server the way a
+ * store's scanner does: plain POSTs, JSON or SSE replies, a session id if the
+ * server hands one out.
+ */
+export interface RpcReply {
+    status: number;
+    contentType: string;
+    body: any;
+    headers: Headers;
+}
+export declare class McpClient {
+    readonly url: string;
+    private extraHeaders;
+    private timeoutMs;
+    private session;
+    private id;
+    constructor(url: string, extraHeaders?: Record<string, string>, timeoutMs?: number);
+    request(method: string, params?: unknown, opts?: {
+        notification?: boolean;
+        url?: string;
+    }): Promise<RpcReply>;
+    initialize(): Promise<RpcReply>;
+}

package/dist/mcp-server.d.ts

@@ -0,0 +1 @@
+export declare function serve(): Promise<void>;

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.d.ts

@@ -0,0 +1,32 @@
+import type { Manifest, StoreId, Tool } from './types.js';
+export interface Pack {
+    files: {
+        path: string;
+        content: string;
+    }[];
+    problems: string[];
+    todo: string[];
+}
+/** "Add the user's…" → "adds the user's…"; leaves non-verb openings alone. */
+declare function thirdPerson(s: string): string | null;
+/** One-sentence drafts from the declared hints and the tool's own description. Review them: they are a start, not an answer. */
+declare function justify(t: Tool, product: string, own?: {
+    readOnly?: string;
+    openWorld?: string;
+    destructive?: string;
+}): {
+    read_only_justification: string;
+    open_world_justification: string;
+    destructive_justification: string;
+};
+export declare function chatgptPack(m: Manifest, token?: string): Promise<Pack>;
+export declare function claudePack(m: Manifest, token?: string): Promise<Pack>;
+export declare function simplePack(m: Manifest, store: StoreId): Promise<Pack>;
+/** The long tail: directories that only take a web form. One sheet with every value to paste. */
+export declare function directoriesPack(m: Manifest): Pack;
+export declare function writePack(pack: Pack, dir?: string): Promise<string[]>;
+export declare const _test: {
+    thirdPerson: typeof thirdPerson;
+    justify: typeof justify;
+};
+export {};

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.d.ts

@@ -0,0 +1,9 @@
+import { type PreflightResult } from './core.js';
+import type { Manifest, StoreId } from './types.js';
+export type { PreflightResult } from './core.js';
+/** Preflight with everything Node can check, the TLS 1.2 handshake included. */
+export declare function preflight(m: Manifest, opts?: {
+    stores?: StoreId[];
+    register?: boolean;
+    token?: string;
+}): Promise<PreflightResult>;

package/dist/preflight.js

@@ -1,39 +1,6 @@
-import { authChecks } from './checks/auth.js';
-import { listingChecks, repoChecks } from './checks/listing.js';
-import { serverChecks } from './checks/server.js';
-import { toolChecks } from './checks/tools.js';
-import { storesOf } from './manifest.js';
-/** Things no script can see, which have still cost real submissions. */
-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('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.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.');
-        r.push('Tool-annotation justifications are cut at 200 characters without warning.');
-        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-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.');
-    }
-    return r;
-}
-export async function preflight(m, opts = {}) {
-    const stores = opts.stores?.length ? opts.stores : storesOf(m);
-    const auth = m.server.auth ?? 'none';
-    const server = await serverChecks(m.server.url, auth, opts.token);
-    const [authC, listing, repo] = await Promise.all([
-        auth === 'oauth' ? authChecks(m.server.url, { register: opts.register }) : Promise.resolve([]),
-        listingChecks(m, server.tools, stores),
-        repoChecks(m, stores),
-    ]);
-    const all = [...server.checks, ...authC, ...toolChecks(server.tools), ...listing, ...repo];
-    // Keep checks that apply to every store or to one we're submitting to.
-    const checks = all.filter((c) => !c.stores?.length || c.stores.some((s) => stores.includes(s)));
-    return { checks, reminders: reminders(m, stores), stores };
+import { tls12Check } from './checks/tls.js';
+import { preflight as core } from './core.js';
+/** Preflight with everything Node can check, the TLS 1.2 handshake included. */
+export function preflight(m, opts = {}) {
+    return core(m, { ...opts, extraChecks: [tls12Check] });
 }