mcplane 0.1.0

package/dist/extras.js

@@ -0,0 +1,109 @@
+/**
+ * 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'],
+    // Everything for a release: checks, packs, the stores that can be automated, then your hand-offs.
+    release: [
+        'preflight',
+        'drift',
+        'pack chatgpt',
+        'pack claude-connectors',
+        'publish mcp-registry',
+        'publish grok',
+        'handoff: Upload .mcplane/packs/chatgpt-app-submission.json in the ChatGPT portal, tick the policy statements and submit. Then: mcplane submitted chatgpt --app-id <asdk_app_…>',
+        'handoff: Paste .mcplane/packs/claude-connectors.md into claude.ai/directory/manage/new, make the compliance statements yourself and submit. Then: mcplane submitted claude-connectors',
+    ],
+};
+export function lanes(m) {
+    return { ...DEFAULT_LANES, ...(m.lanes ?? {}) };
+}
+/**
+ * Runs a lane step by step. A step that fails stops the lane unless it starts
+ * with "?" (optional). "handoff:" steps are what only a person can do: policy
+ * statements, the final submit. They're collected and shown at the end.
+ */
+export function runLane(name, steps, passthrough) {
+    const handoffs = [];
+    const me = process.argv[1];
+    for (const raw of steps) {
+        if (raw.startsWith('handoff:')) {
+            handoffs.push(raw.slice(8).trim());
+            continue;
+        }
+        const optional = raw.startsWith('?');
+        const step = optional ? raw.slice(1).trim() : raw.trim();
+        console.log(`\n▸ mcplane ${step}`);
+        const r = spawnSync(process.execPath, [...process.execArgv, me, ...step.split(/\s+/), ...passthrough], { stdio: 'inherit' });
+        if (r.status !== 0 && !optional) {
+            console.log(`\nLane "${name}" stopped at "${step}". Fix that, then run "mcplane ${name}" again.`);
+            return r.status ?? 1;
+        }
+    }
+    if (handoffs.length) {
+        console.log('\nYour turn (only you can do these):');
+        handoffs.forEach((h, i) => console.log(`  ${i + 1}. ${h}`));
+    }
+    console.log(`\nLane "${name}" done.`);
+    return 0;
+}
+/* ---------------- try ---------------- */
+export function tryLinks(m) {
+    const name = m.name;
+    const url = m.server.url;
+    const cursorConfig = Buffer.from(JSON.stringify({ url })).toString('base64');
+    const vscode = encodeURIComponent(JSON.stringify({ name, type: 'http', url }));
+    return [
+        { client: 'Claude Code', how: `claude mcp add --transport http ${name} ${url}` },
+        { client: 'Cursor', how: `cursor://anysphere.cursor-deeplink/mcp/install?name=${encodeURIComponent(name)}&config=${cursorConfig}` },
+        { client: 'VS Code', how: `vscode:mcp/install?${vscode}` },
+        { client: 'Claude (web, desktop)', how: `Settings → Connectors → Add custom connector → ${url}` },
+        { 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

@@ -0,0 +1,112 @@
+/**
+ * Fleet: many MCP servers, one view. Finds every mcplane.json under a folder
+ * (your ~/Projects, a monorepo) and runs checks across all of them, so
+ * seventeen apps cost the same attention as one.
+ */
+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 { 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']);
+/** 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 = [];
+    const walk = async (dir, level) => {
+        const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+        if (entries.some((e) => e.isFile() && e.name === MANIFEST_FILE)) {
+            const p = { dir, path: relative(root, dir) || '.' };
+            try {
+                p.manifest = await loadManifest(dir);
+            }
+            catch (e) {
+                p.error = e.message;
+            }
+            found.push(p);
+        }
+        if (level >= depth)
+            return;
+        for (const e of entries)
+            if (e.isDirectory() && !SKIP.has(e.name) && !e.name.startsWith('.'))
+                await walk(join(dir, e.name), level + 1);
+    };
+    await walk(resolve(root), 0);
+    return found;
+}
+/** Runs fn over items, a few at a time. */
+async function pool(items, n, fn) {
+    const out = new Array(items.length);
+    let i = 0;
+    await Promise.all(Array.from({ length: Math.min(n, items.length) }, async () => {
+        while (i < items.length) {
+            const k = i++;
+            out[k] = await fn(items[k]);
+        }
+    }));
+    return out;
+}
+/** Preflight, drift 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) => {
+        const subs = await load(p.dir);
+        const row = {
+            project: p.path,
+            name: p.manifest?.title,
+            url: p.manifest?.server.url,
+            waiting: subs.filter((s) => s.status === 'waiting').map((s) => ({ store: s.store, since: s.submittedOn })),
+            live: [...new Set(subs.filter((s) => s.status === 'approved').map((s) => s.store))],
+            error: p.error,
+        };
+        if (!p.manifest || opts.checks === false)
+            return row;
+        try {
+            const r = await preflight(p.manifest, { token: opts.token });
+            row.blocking = r.checks.filter((c) => c.level === 'fail').length;
+            row.toReview = r.checks.filter((c) => c.level === 'warn').length;
+            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;
+        }
+        catch (e) {
+            row.error = e.message;
+        }
+        return row;
+    });
+}
+export function printFleet(rows) {
+    if (!rows.length) {
+        console.log(`No ${MANIFEST_FILE} found here or a few folders down. Run "mcplane init --url <server>" in each project.`);
+        return;
+    }
+    for (const r of rows) {
+        const bits = [
+            r.error ? `error: ${r.error}` : r.blocking === undefined ? '' : r.blocking ? `${r.blocking} blocking` : 'preflight clean',
+            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(', ')}` : '',
+        ].filter(Boolean);
+        const mark = r.error || r.blocking || r.driftActions?.length ? '✗' : '✓';
+        console.log(`${mark} ${(r.name ?? r.project).padEnd(24)} ${bits.join(' · ')}`);
+        for (const a of r.driftActions ?? [])
+            console.log(`    ${a.store}: ${a.what}`);
+    }
+    const bad = rows.filter((r) => r.error || r.blocking || r.driftActions?.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. */
+export async function fleetRun(root, args) {
+    const projects = (await findProjects(root)).filter((p) => p.manifest);
+    let failed = 0;
+    for (const p of projects) {
+        console.log(`\n━━ ${p.manifest.title} (${p.path})`);
+        const r = spawnSync(process.execPath, [...process.execArgv, process.argv[1], ...args], { cwd: p.dir, stdio: 'inherit' });
+        if (r.status !== 0)
+            failed++;
+    }
+    console.log(`\n${projects.length - failed} of ${projects.length} succeeded.`);
+    return failed ? 1 : 0;
+}

package/dist/manifest.js

@@ -0,0 +1,97 @@
+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 const MANIFEST_FILE = 'mcplane.json';
+export const SCHEMA_URL = 'https://unpkg.com/mcplane/schema.json';
+export async function loadManifest(dir = process.cwd()) {
+    const path = resolve(dir, MANIFEST_FILE);
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch {
+        throw new Error(`No ${MANIFEST_FILE} here. Run "mcplane init --url <your MCP server URL>" to create one.`);
+    }
+    let m;
+    try {
+        m = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`${MANIFEST_FILE} isn't valid JSON: ${e.message}`);
+    }
+    const problems = [];
+    if (!m.name)
+        problems.push('"name" is required');
+    if (!m.title)
+        problems.push('"title" is required');
+    if (!m.server?.url)
+        problems.push('"server.url" is required');
+    for (const s of m.stores ?? [])
+        if (!(s in STORE_NAMES))
+            problems.push(`unknown store "${s}"`);
+    if (problems.length)
+        throw new Error(`${MANIFEST_FILE}: ${problems.join('; ')}`);
+    return m;
+}
+/**
+ * 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 async function ensureLocalDir(dir = process.cwd()) {
+    const d = resolve(dir, '.mcplane');
+    await mkdir(d, { recursive: true });
+    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.js

@@ -0,0 +1,70 @@
+const UA = 'mcplane (+https://github.com/stevysmith/mcplane)';
+export class McpClient {
+    url;
+    extraHeaders;
+    timeoutMs;
+    session = null;
+    id = 0;
+    constructor(url, extraHeaders = {}, timeoutMs = 15_000) {
+        this.url = url;
+        this.extraHeaders = extraHeaders;
+        this.timeoutMs = timeoutMs;
+    }
+    async request(method, params, opts = {}) {
+        const body = opts.notification ? { jsonrpc: '2.0', method, params } : { jsonrpc: '2.0', id: ++this.id, method, params };
+        const headers = {
+            'content-type': 'application/json',
+            accept: 'application/json, text/event-stream',
+            'mcp-protocol-version': '2025-06-18',
+            'user-agent': UA,
+            ...this.extraHeaders,
+        };
+        if (this.session)
+            headers['mcp-session-id'] = this.session;
+        const res = await fetch(opts.url ?? this.url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(this.timeoutMs),
+        });
+        const sid = res.headers.get('mcp-session-id');
+        if (sid)
+            this.session = sid;
+        const contentType = res.headers.get('content-type') ?? '';
+        const text = await res.text();
+        return { status: res.status, contentType, body: parseBody(text, contentType), headers: res.headers };
+    }
+    async initialize() {
+        const r = await this.request('initialize', {
+            protocolVersion: '2025-06-18',
+            capabilities: {},
+            clientInfo: { name: 'mcplane', version: '0.1.0' },
+        });
+        if (r.status < 300)
+            await this.request('notifications/initialized', undefined, { notification: true }).catch(() => null);
+        return r;
+    }
+}
+/** JSON, or the last JSON-RPC message in an SSE stream. */
+function parseBody(text, contentType) {
+    if (contentType.includes('text/event-stream')) {
+        const datas = text
+            .split(/\r?\n/)
+            .filter((l) => l.startsWith('data:'))
+            .map((l) => l.slice(5).trim())
+            .filter(Boolean);
+        for (let i = datas.length - 1; i >= 0; i--) {
+            try {
+                return JSON.parse(datas[i]);
+            }
+            catch { }
+        }
+        return null;
+    }
+    try {
+        return text ? JSON.parse(text) : null;
+    }
+    catch {
+        return text;
+    }
+}

package/dist/mcp-server.js

@@ -0,0 +1,172 @@
+/**
+ * `mcplane mcp`: the same commands as MCP tools over stdio, so Claude Code,
+ * Codex or Cursor can check, prepare and track submissions from inside the
+ * repo. Every tool takes an optional project folder (default: where the
+ * server was started), and fleet covers every project under a folder at once.
+ */
+import { access, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+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 { MANIFEST_FILE, draftManifest, loadManifest, storesOf } from './manifest.js';
+import { chatgptPack, claudePack, directoriesPack, simplePack, writePack } from './packs.js';
+import { preflight } from './preflight.js';
+import { publish } from './publish.js';
+import { recordDecision, recordSubmitted, status } from './submissions.js';
+import { STORE_NAMES } from './types.js';
+import { VERSION } from './version.js';
+const STORE = z.enum(Object.keys(STORE_NAMES));
+const reply = (data, summary) => ({
+    content: [{ type: 'text', text: summary ? `${summary}\n\n${JSON.stringify(data, null, 2)}` : JSON.stringify(data, null, 2) }],
+    structuredContent: data,
+});
+const token = () => process.env.MCPLANE_TOKEN;
+const PROJECT = z.string().optional().describe('Folder holding mcplane.json. Defaults to the folder mcplane was started in.');
+const dirOf = (p) => resolve(p ?? process.cwd());
+export async function serve() {
+    const server = new McpServer({ name: 'mcplane', title: 'mcplane', version: VERSION });
+    server.registerTool('preflight', {
+        title: 'Check an MCP server against store review rules',
+        description: 'Checks a live MCP server, its listing links, icon and plugin repo against the known rejection causes of ChatGPT, Claude, Cursor, Grok, Muse and the MCP Registry. Returns each check with pass, warn, fail or skip, what was found and how to fix it, plus reminders that no script can verify. Uses mcplane.json, or a url for a server without one.',
+        inputSchema: { project: PROJECT, url: z.string().url().optional(), stores: z.array(STORE).optional() },
+        annotations: { title: 'Preflight', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ project, url, stores }) => {
+        const m = url ? await draftManifest(url) : await loadManifest(dirOf(project));
+        const r = await preflight(m, { stores, token: token() });
+        const fails = r.checks.filter((c) => c.level === 'fail').length;
+        return reply(r, `${fails} blocking, ${r.checks.filter((c) => c.level === 'warn').length} to review, ${r.checks.filter((c) => c.level === 'pass').length} passed.`);
+    });
+    server.registerTool('drift', {
+        title: 'What each store needs since your last submission',
+        description: 'Compares the live server and mcplane.json with the snapshot saved when each submission was recorded, and lists what each store needs: a new ChatGPT version, a Claude listing edit, a plugin pin bump. Stores without a snapshot are listed as missing.',
+        inputSchema: { project: PROJECT, stores: z.array(STORE).optional() },
+        annotations: { title: 'Drift', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ project, stores }) => {
+        const m = await loadManifest(dirOf(project));
+        const r = await drift(m, stores?.length ? stores : storesOf(m), { token: token() }, dirOf(project));
+        return reply(r, r.items.length ? `${r.items.filter((i) => i.level === 'action').length} store actions needed.` : 'No drift.');
+    });
+    server.registerTool('pack', {
+        title: 'Write a submission pack',
+        description: 'Writes everything a store’s submission form asks for into .mcplane/packs: chatgpt-app-submission.json for ChatGPT’s import, markdown packs for claude-connectors, cursor and muse, and one sheet for the form-only directories. Returns the files written and any problems to fix first.',
+        inputSchema: { project: PROJECT, store: z.enum(['chatgpt', 'claude-connectors', 'cursor', 'muse', 'directories']) },
+        annotations: { title: 'Pack', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ project, store }) => {
+        const m = await loadManifest(dirOf(project));
+        const pack = store === 'directories' ? directoriesPack(m) : store === 'chatgpt' ? await chatgptPack(m, token()) : store === 'claude-connectors' ? await claudePack(m, token()) : await simplePack(m, store);
+        const files = await writePack(pack, dirOf(project));
+        return reply({ files, problems: pack.problems, todo: pack.todo });
+    });
+    server.registerTool('publish', {
+        title: 'Publish to a store that allows automation',
+        description: 'mcp-registry: writes server.json and runs mcp-publisher (a published registry version can’t be changed afterwards). grok: opens a pull request to xai-org/plugin-marketplace (new listing or pin bump), validated with xAI’s scripts. Other stores return the prepared entry or command. With confirm false it returns what it would do and changes nothing.',
+        inputSchema: { project: PROJECT, store: STORE, confirm: z.boolean().default(false) },
+        annotations: { title: 'Publish', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+    }, async ({ project, store, confirm }) => {
+        const m = await loadManifest(dirOf(project));
+        const r = await publish(m, store, { yes: confirm, dir: dirOf(project) });
+        if (r.done && confirm && (store === 'mcp-registry' || store === 'grok')) {
+            const rec = await recordSubmitted(m, store, { version: m.version, share: true }, dirOf(project)).catch(() => null);
+            return reply({ ...r, recorded: rec?.note ?? null });
+        }
+        return reply(r);
+    });
+    server.registerTool('record_submission', {
+        title: 'Record a store submission',
+        description: 'Records that the developer submitted to a store, saves a snapshot for drift, and logs an anonymous public report to Review Times (reviewtimes.fyi) so the wait counts toward the store’s public numbers. share false keeps it local.',
+        inputSchema: {
+            project: PROJECT,
+            store: STORE,
+            date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+            kind: z.enum(['new', 'update', 'resubmission']).optional(),
+            version: z.string().optional(),
+            app_id: z.string().optional(),
+            share: z.boolean().default(true),
+        },
+        annotations: { title: 'Record submission', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async ({ project, store, date, kind, version, app_id, share }) => {
+        const m = await loadManifest(dirOf(project));
+        return reply(await recordSubmitted(m, store, { date, kind, version, appId: app_id, share, token: token() }, dirOf(project)));
+    });
+    server.registerTool('record_decision', {
+        title: 'Record a store’s decision',
+        description: 'Marks the latest waiting submission to a store as approved, rejected or withdrawn, and updates its Review Times report.',
+        inputSchema: { project: PROJECT, store: STORE, outcome: z.enum(['approved', 'rejected', 'withdrawn']), date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional() },
+        annotations: { title: 'Record decision', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ project, store, outcome, date }) => reply(await recordDecision(store, outcome, date, dirOf(project))));
+    server.registerTool('submission_status', {
+        title: 'Your submissions and how long they’ve waited',
+        description: 'Every recorded submission with days waited, refreshed from Review Times (which closes reports itself when a listing appears), and each store’s typical wait right now.',
+        inputSchema: { project: PROJECT },
+        annotations: { title: 'Status', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ project }) => reply({ submissions: await status(dirOf(project)) }));
+    server.registerTool('install_links', {
+        title: 'Install links for every client',
+        description: 'Install commands and links for Claude Code, Cursor, VS Code, Claude and ChatGPT developer mode, for testing before and after listing.',
+        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('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.',
+        inputSchema: { project: PROJECT, url: z.string().url() },
+        annotations: { title: 'Init', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ project, url }) => {
+        const file = join(dirOf(project), MANIFEST_FILE);
+        if (await access(file).then(() => true, () => false))
+            return reply({ error: `${file} already exists` });
+        const m = await draftManifest(url);
+        await writeFile(file, JSON.stringify(m, null, 2) + '\n');
+        return reply({ written: file, manifest: m }, 'Fill in subtitle, oneLiner, description and tests, then run preflight.');
+    });
+    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.',
+        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;
+        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.
+    const say = (text) => ({ messages: [{ role: 'user', content: { type: 'text', text } }] });
+    server.registerPrompt('onboard', {
+        title: 'Get an MCP server ready for the stores',
+        description: 'Creates mcplane.json, writes the listing and review tests from the code, and runs preflight.',
+        argsSchema: { url: z.string().describe('The server’s public MCP URL'), project: z.string().optional().describe('Project folder, if not the current one') },
+    }, ({ url, project }) => say(`Get this MCP server ready for store submission with mcplane.${project ? ` The project is in ${project}; pass it as "project" to every mcplane tool.` : ''}
+
+1. Call mcplane's init tool with url ${url}. If mcplane.json already exists, read it instead.
+2. Read the server's code and README, then fill in mcplane.json:
+   - title; subtitle (30 characters max, no "AI" filler); oneLiner (one plain sentence: what it does); description (what it does, who it's for, what it can't do).
+   - category (a ChatGPT category such as DEVELOPER_TOOLS or PRODUCTIVITY), stores (where it should list), repository if there's a public plugin repo, version.
+   - tests: exactly 5 positive cases (scenario, a realistic user prompt, the tools it should call, the expected result) and 3 negative cases (prompts that should NOT trigger this app). Base them on real tool behaviour, not hopes.
+   - justifications, only where the drafts would be wrong: one factual sentence per hint, under 200 characters.
+   Write in plain language. No marketing words, no instructions to the model, no pricing or upgrade copy.
+3. Call preflight. Fix what you can in the code (annotations, titles, output schemas, descriptions) and list what needs me (legal pages, icon, OAuth setup).
+4. Show me the final listing text and the tests before anything is submitted.`));
+    server.registerPrompt('ship', {
+        title: 'Ship to the stores',
+        description: 'Checks, prepares every submission, publishes where the store allows it, and lists exactly what is left for you.',
+        argsSchema: { project: z.string().optional().describe('Project folder, if not the current one') },
+    }, ({ project }) => say(`Ship this MCP server to its stores with mcplane.${project ? ` Pass project "${project}" to every mcplane tool.` : ''}
+
+1. preflight. If anything is blocking, stop and fix it (or tell me what needs me).
+2. drift, to see what each store needs since the last submission.
+3. pack for each form-based store in mcplane.json (chatgpt, claude-connectors, cursor, muse).
+4. publish with confirm false for mcp-registry and grok, show me what it would do, and on my go-ahead publish with confirm true.
+5. For the form-based stores, give me one short checklist: which file to upload or paste where, and the statements only I can make. If you have browser tools, offer to fill the form fields from the pack; I tick the policy statements and press submit myself.
+6. After I say I've submitted, call record_submission for each store (ChatGPT: ask me for the asdk_app_ id).`));
+    await server.connect(new StdioServerTransport());
+}