mcplane 0.4.0 → 0.5.0

package/dist/evals.js

@@ -0,0 +1,75 @@
+const safe = (s) => s.replace(/[^a-zA-Z0-9_-]/g, '_');
+/** How Claude Code names a plugin's MCP tools. */
+export const toolId = (p, tool) => `mcp__plugin_${safe(p.plugin)}_${safe(p.server)}__${tool}`;
+/** Case directory names: stable, ordered and readable, cut at a word. */
+export const caseSlug = (s) => {
+    const slug = s
+        .toLowerCase()
+        .replace(/['’]/g, '')
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+    return slug.length <= 48 ? slug : slug.slice(0, 49).replace(/-[^-]*$/, '');
+};
+/** Markdown with YAML frontmatter. Strings go out as JSON, which YAML reads as quoted scalars, so quotes and colons can't break it. */
+export function frontmatter(fields, body = '') {
+    const value = (v) => (Array.isArray(v) ? `[${v.map(value).join(', ')}]` : typeof v === 'string' ? JSON.stringify(v) : String(v));
+    const lines = Object.entries(fields)
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${k}: ${value(v)}`);
+    return `---\n${lines.join('\n')}\n---\n${body.trim() ? `\n${body.trim()}\n` : ''}`;
+}
+/** An agent mock: a small model answers as the tool, from its description and output schema. */
+function mock(m, name, tool, test) {
+    const lines = [
+        `You are the ${name} tool of ${m.title}'s MCP server (${m.server.url}).`,
+        tool?.description ? `What it does: ${tool.description}` : '',
+        tool?.outputSchema ? `Reply with JSON that matches this output schema, with realistic values: ${JSON.stringify(tool.outputSchema)}` : 'Reply the way the real tool would, with realistic values.',
+        test ? `In this case the user asked: "${test.prompt}". Return what lets the assistant give this: ${test.expected}` : '',
+        'Never say that you are a stand-in.',
+    ];
+    return frontmatter({ type: 'agent' }, lines.filter(Boolean).join('\n'));
+}
+export function evalSuite(m, p, tools) {
+    const files = [];
+    const problems = [];
+    const pos = m.tests?.positive ?? [];
+    const neg = m.tests?.negative ?? [];
+    if (!pos.length && !neg.length)
+        problems.push('mcplane.json has no tests.positive or tests.negative to turn into cases');
+    const live = new Set(tools.map((t) => t.name));
+    // Without a live tool list (sign-in), the tools the tests name are all we know.
+    const names = tools.length ? tools.map((t) => t.name) : [...new Set(pos.flatMap((t) => t.tools))];
+    const toolNamed = (n) => tools.find((t) => t.name === n);
+    pos.forEach((t, i) => {
+        const dir = `evals/positive-${i + 1}-${caseSlug(t.scenario)}`;
+        files.push({ path: `${dir}/prompt.md`, content: frontmatter({ description: t.scenario, tags: ['mcplane', 'positive'], expected_outcome: t.expected, max_turns: 10, allowed_tools: ['Skill'] }, t.prompt) });
+        for (const name of t.tools) {
+            if (tools.length && !live.has(name))
+                problems.push(`test "${t.scenario}" names a tool the server doesn't have: ${name}`);
+            // Not scored: it can't pass without the plugin, and counting it would inflate the plugin's delta.
+            files.push({ path: `${dir}/graders/calls-${name}.md`, content: frontmatter({ type: 'tool_used', tool: toolId(p, name), arm: 'with-only' }) });
+            files.push({ path: `${dir}/mocks/${p.server}/${name}.md`, content: mock(m, name, toolNamed(name), t) });
+        }
+        files.push({
+            path: `${dir}/graders/answer.md`,
+            content: frontmatter({ type: 'llm' }, `PASS if the reply gives the user what this request should get: ${t.expected}\nFAIL if it doesn't, or if it says a tool failed or wasn't available.`),
+        });
+    });
+    // A case with no grader fails to load, and a negative case's graders are the tool names.
+    if (neg.length && !names.length)
+        problems.push('No tool names for the negative cases: tools/list returned none (pass --token for a server behind sign-in) and no positive test names a tool');
+    if (names.length)
+        neg.forEach((t, i) => {
+            const dir = `evals/negative-${i + 1}-${caseSlug(t.scenario)}`;
+            files.push({ path: `${dir}/prompt.md`, content: frontmatter({ description: t.scenario, tags: ['mcplane', 'negative'], max_turns: 6, allowed_tools: ['Skill'] }, t.prompt) });
+            // Scored in both arms: staying quiet is the point.
+            for (const name of names)
+                files.push({ path: `${dir}/graders/no-${name}.md`, content: frontmatter({ type: 'tool_used', tool: toolId(p, name), min: 0, max: 0, arm: 'both' }) });
+        });
+    // Suite-wide mocks for every tool, so a call in any case gets an answer rather than a missing tool.
+    if (tools.length)
+        files.push({ path: `evals/mocks/${p.server}/_tools.json`, content: JSON.stringify({ tools }, null, 2) + '\n' });
+    for (const name of names)
+        files.push({ path: `evals/mocks/${p.server}/${name}.md`, content: mock(m, name, toolNamed(name)) });
+    return { files, problems };
+}

package/dist/extras.js

@@ -18,7 +18,7 @@ export const DEFAULT_LANES = {
         'pack claude-connectors',
         'publish mcp-registry',
         'publish grok',
-        'handoff: Upload the ZIP in .mcplane/packs/chatgpt/ at platform.openai.com/plugins, add reviewer credentials and hint justifications (see chatgpt.md), make the attestations and submit. Then: mcplane submitted chatgpt --app-id <asdk_app_…>',
+        'handoff: Upload the ZIP in .mcplane/packs/chatgpt/ at platform.openai.com/plugins, add reviewer credentials (see chatgpt.md), make the attestations 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',
     ],
 };

package/dist/images.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Image facts the stores check, read from the bytes rather than the name or content type:
+ * the format, and pixel (or SVG viewBox) dimensions. Enough of PNG, JPEG, WebP and SVG to say
+ * whether an icon is square and big enough. No dependencies, so it runs anywhere.
+ */
+export type ImageFormat = 'png' | 'jpeg' | 'webp' | 'svg';
+export interface ImageInfo {
+    format: ImageFormat | null;
+    width?: number;
+    height?: number;
+    /** Why the dimensions couldn't be read. */
+    error?: string;
+}
+export declare const EXTENSION: Record<ImageFormat, string>;
+export declare function sniff(b: Uint8Array): ImageFormat | null;
+export declare function imageInfo(bytes: Uint8Array): ImageInfo;
+/** What's wrong with an image as a store icon: square, and 48 to 4096 px for raster formats. Empty when it's fine. */
+export declare function iconProblems(info: ImageInfo, label: string, opts?: {
+    min?: number;
+    max?: number;
+}): string[];

package/dist/images.js

@@ -0,0 +1,99 @@
+export const EXTENSION = { png: 'png', jpeg: 'jpg', webp: 'webp', svg: 'svg' };
+const ascii = (b, from, to) => String.fromCharCode(...b.subarray(from, to));
+export function sniff(b) {
+    if (b.length >= 8 && [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a].every((v, i) => b[i] === v))
+        return 'png';
+    if (b.length >= 3 && b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff)
+        return 'jpeg';
+    if (b.length >= 12 && ascii(b, 0, 4) === 'RIFF' && ascii(b, 8, 12) === 'WEBP')
+        return 'webp';
+    const head = new TextDecoder().decode(b.subarray(0, 8192)).replace(/^/, '').trimStart();
+    if (/^(<\?xml[^>]*>\s*)?(<!--[\s\S]*?-->\s*)*(<!DOCTYPE[^>]*>\s*)?(<!--[\s\S]*?-->\s*)*<svg[\s>]/i.test(head))
+        return 'svg';
+    return null;
+}
+function png(b, v) {
+    if (b.length < 24 || ascii(b, 12, 16) !== 'IHDR')
+        throw new Error('PNG has no IHDR chunk');
+    return { width: v.getUint32(16), height: v.getUint32(20) };
+}
+function jpeg(b, v) {
+    let p = 2;
+    while (p + 9 < b.length) {
+        if (b[p] !== 0xff)
+            throw new Error('JPEG segment marker missing');
+        const marker = b[p + 1];
+        if (marker === 0xd9 || marker === 0xda)
+            break;
+        // Start-of-frame markers carry the size; C4, C8 and CC are other segments in the same range.
+        if (marker >= 0xc0 && marker <= 0xcf && ![0xc4, 0xc8, 0xcc].includes(marker))
+            return { height: v.getUint16(p + 5), width: v.getUint16(p + 7) };
+        p += 2 + v.getUint16(p + 2);
+    }
+    throw new Error('JPEG has no frame header');
+}
+function webp(b, v) {
+    const chunk = ascii(b, 12, 16);
+    const u24 = (at) => b[at] | (b[at + 1] << 8) | (b[at + 2] << 16);
+    if (chunk === 'VP8 ' && b.length >= 30)
+        return { width: v.getUint16(26, true) & 0x3fff, height: v.getUint16(28, true) & 0x3fff };
+    if (chunk === 'VP8L' && b.length >= 25) {
+        const bits = v.getUint32(21, true);
+        return { width: (bits & 0x3fff) + 1, height: ((bits >>> 14) & 0x3fff) + 1 };
+    }
+    if (chunk === 'VP8X' && b.length >= 30)
+        return { width: u24(24) + 1, height: u24(27) + 1 };
+    throw new Error(`unknown WebP chunk "${chunk}"`);
+}
+function svg(src) {
+    const root = /<svg\b([^>]*)>/i.exec(src.replace(/<!--[\s\S]*?-->/g, ''));
+    if (!root)
+        throw new Error('no <svg> element');
+    const attr = (n) => new RegExp(`\\s${n}\\s*=\\s*["']([^"']*)["']`, 'i').exec(root[1])?.[1];
+    const vb = attr('viewBox');
+    if (vb) {
+        const parts = vb.trim().split(/[\s,]+/).map(Number);
+        if (parts.length !== 4 || parts.some((n) => !Number.isFinite(n)))
+            throw new Error(`viewBox "${vb}" isn't four numbers`);
+        return { width: parts[2], height: parts[3] };
+    }
+    const [w, h] = [attr('width'), attr('height')];
+    if (!w || !h)
+        throw new Error('the SVG has neither a viewBox nor a width and height');
+    if (!/^\d+(\.\d+)?(px)?$/.test(w) || !/^\d+(\.\d+)?(px)?$/.test(h))
+        throw new Error(`width "${w}" and height "${h}" aren't plain numbers`);
+    return { width: parseFloat(w), height: parseFloat(h) };
+}
+export function imageInfo(bytes) {
+    const format = sniff(bytes);
+    if (!format)
+        return { format, error: 'not a PNG, JPEG, WebP or SVG file' };
+    const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    try {
+        if (format === 'png')
+            return { format, ...png(bytes, v) };
+        if (format === 'jpeg')
+            return { format, ...jpeg(bytes, v) };
+        if (format === 'webp')
+            return { format, ...webp(bytes, v) };
+        return { format, ...svg(new TextDecoder().decode(bytes)) };
+    }
+    catch (e) {
+        return { format, error: e.message };
+    }
+}
+/** What's wrong with an image as a store icon: square, and 48 to 4096 px for raster formats. Empty when it's fine. */
+export function iconProblems(info, label, opts = {}) {
+    const min = opts.min ?? 48;
+    const max = opts.max ?? 4096;
+    if (!info.format || info.error || info.width === undefined || info.height === undefined)
+        return [`${label} ${info.error ?? "can't be read"}`];
+    const out = [];
+    if (info.width !== info.height)
+        out.push(`${label} is ${info.width}×${info.height}; it must be square`);
+    else if (info.format !== 'svg' && (info.width < min || info.width > max))
+        out.push(`${label} is ${info.width} px; it must be ${min} to ${max} px`);
+    else if (info.format === 'svg' && info.width < min)
+        out.push(`${label}'s viewBox is ${info.width} units; make it at least ${min}`);
+    return out;
+}

package/dist/listings.d.ts

@@ -7,6 +7,20 @@ export interface Listing {
     issues: string[];
     note?: string;
 }
+export interface ConnectEntry {
+    slug: string;
+    name: string;
+    description: string;
+    /** Managed, OAuth, MCP, API Key, Beta. */
+    labels: string[];
+    /** "Experimental. This connector provider has not been verified by Vercel." */
+    experimental: boolean;
+}
+/**
+ * Vercel's directory has no feed, but serves an agent-readable copy of the page at /connect/browse.md:
+ * each service is **Name** and a description, its labels one per line, then [Learn more](/connect/<slug>).
+ */
+export declare function parseConnectDirectory(md: string): ConnectEntry[];
 export declare function printListings(rows: Listing[]): void;
 export declare function listings(m: Manifest, stores: StoreId[], opts?: {
     token?: string;

package/dist/listings.js

@@ -107,7 +107,7 @@ 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.' };
+        return { store: 'glama', state: 'listed', url, issues: [], note: 'Imported from the registry. Claim it (Claim ownership on that page; "mcplane publish glama" has the steps) so the listing and badge are 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: [] };
@@ -124,6 +124,43 @@ 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: [] };
 }
+const CONNECT_LABELS = ['Managed', 'OAuth', 'MCP', 'API Key', 'Beta'];
+/**
+ * Vercel's directory has no feed, but serves an agent-readable copy of the page at /connect/browse.md:
+ * each service is **Name** and a description, its labels one per line, then [Learn more](/connect/<slug>).
+ */
+export function parseConnectDirectory(md) {
+    const parts = md.split(/\[Learn more\]\(\/connect\/([a-z0-9-]+)\)/);
+    const out = [];
+    for (let i = 0; i + 1 < parts.length; i += 2) {
+        const name = [...parts[i].matchAll(/\*\*([^*\n]+)\*\*/g)].pop();
+        if (!name)
+            continue;
+        const lines = parts[i]
+            .slice(name.index + name[0].length)
+            .split('\n')
+            .map((l) => l.trim())
+            .filter(Boolean);
+        const text = lines.filter((l) => !CONNECT_LABELS.includes(l)).join(' ');
+        const experimental = /^Experimental\./.test(text);
+        out.push({ slug: parts[i + 1], name: name[1].trim(), description: text.replace(/^Experimental\.[^.]*\./, '').trim(), labels: lines.filter((l) => CONNECT_LABELS.includes(l)), experimental });
+    }
+    return out;
+}
+async function vercelConnect(m) {
+    m = forStore(m, 'vercel-connect');
+    const browse = 'https://vercel.com/connect/browse';
+    const entries = parseConnectDirectory((await getText(`${browse}.md`)) ?? '');
+    // It's a page, not an API: if it stops parsing, say so rather than report "missing".
+    if (entries.length < 100)
+        return { store: 'vercel-connect', state: 'unknown', issues: [], note: `Couldn't read Vercel's directory. Check your listing at ${browse}.` };
+    const slug = m.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    const hit = entries.find((e) => e.slug === m.name || e.slug === slug || e.name.toLowerCase() === m.title.toLowerCase());
+    if (!hit)
+        return { store: 'vercel-connect', state: 'missing', issues: [], note: `Not among its ${entries.length} services, read from the agent-readable copy of ${browse}.` };
+    const note = [hit.labels.join(', '), hit.experimental && 'marked Experimental: not verified by Vercel'].filter(Boolean).join('; ');
+    return { store: 'vercel-connect', state: 'listed', url: `https://vercel.com/connect/${hit.slug}`, issues: [], note: note || undefined };
+}
 export function printListings(rows) {
     const mark = { listed: '✓', missing: '·', unknown: '?' };
     for (const r of rows) {
@@ -165,6 +202,8 @@ export async function listings(m, stores, opts = {}) {
             return awesome(m, s, 'punkpeye/awesome-remote-mcp-servers');
         if (s === 'docker')
             return docker(m);
+        if (s === 'vercel-connect')
+            return vercelConnect(m);
         return Promise.resolve({ store: s, state: 'unknown', issues: [], note: MANUAL[s] });
     });
     return Promise.all(jobs);

package/dist/mcp-client.d.ts

@@ -1,8 +1,3 @@
-/**
- * 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;
@@ -19,6 +14,7 @@ export declare class McpClient {
     request(method: string, params?: unknown, opts?: {
         notification?: boolean;
         url?: string;
+        headers?: Record<string, string>;
     }): Promise<RpcReply>;
     initialize(): Promise<RpcReply>;
 }

package/dist/mcp-client.js

@@ -1,3 +1,9 @@
+/**
+ * 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.
+ */
+import { VERSION } from './version.js';
 const UA = 'mcplane (+https://github.com/stevysmith/mcplane)';
 export class McpClient {
     url;
@@ -18,6 +24,7 @@ export class McpClient {
             'mcp-protocol-version': '2025-06-18',
             'user-agent': UA,
             ...this.extraHeaders,
+            ...opts.headers,
         };
         if (this.session)
             headers['mcp-session-id'] = this.session;
@@ -38,7 +45,7 @@ export class McpClient {
         const r = await this.request('initialize', {
             protocolVersion: '2025-06-18',
             capabilities: {},
-            clientInfo: { name: 'mcplane', version: '0.1.0' },
+            clientInfo: { name: 'mcplane', version: VERSION },
         });
         if (r.status < 300)
             await this.request('notifications/initialized', undefined, { notification: true }).catch(() => null);

package/dist/mcp-server.js

@@ -14,7 +14,7 @@ import { fleet } from './fleet.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 { PACKS, packFor, writePack } from './packs.js';
 import { preflight } from './preflight.js';
 import { publish } from './publish.js';
 import { recordDecision, recordSubmitted, status } from './submissions.js';
@@ -32,14 +32,21 @@ 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() },
+        description: 'Checks a live MCP server, its listing links, icon and plugin repo against the known rejection causes of ChatGPT, Claude, Cursor, Grok, Muse, Vercel Connect and the MCP Registry, plus its ARD manifest and its readiness for MCP 2026-07-28 (checks whose id starts with "readiness."; never blocking). For OAuth servers it also walks the sign-in chain with plain GETs (the authorization endpoint, then the sign-in pages in sign_in or server.signIn) looking for bot challenges and 403s. Returns each check with pass, warn, fail, skip or info (a note that never blocks), 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(),
+            sign_in: z.array(z.string().url()).optional().describe('Sign-in pages or identity-provider URLs the consent screen uses, added to server.signIn.'),
+        },
         annotations: { title: 'Preflight', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    }, async ({ project, url, stores }) => {
+    }, async ({ project, url, stores, sign_in }) => {
         const m = url ? await draftManifest(url) : await loadManifest(dirOf(project));
+        if (sign_in?.length)
+            m.server.signIn = [...(m.server.signIn ?? []), ...sign_in];
         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.`);
+        return reply(r, `${fails} blocking, ${r.checks.filter((c) => c.level === 'warn').length} to review, ${r.checks.filter((c) => c.level === 'info').length} notes, ${r.checks.filter((c) => c.level === 'pass').length} passed.`);
     });
     server.registerTool('drift', {
         title: 'What each store needs since your last submission',
@@ -53,12 +60,16 @@ export async function serve() {
     });
     server.registerTool('pack', {
         title: 'Write a submission pack',
-        description: 'Writes everything a store’s submission form asks for into .mcplane/packs: the plugin ZIP ChatGPT’s portal uploads (listing, icons, 5+3 tests, release notes) with a checklist for the dashboard-only steps, 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']) },
+        description: 'Writes everything a store’s submission form asks for into .mcplane/packs: the plugin ZIP ChatGPT’s portal uploads (listing, icons, 5+3 tests, release notes, and the skills in chatgpt.skills) with a checklist for the dashboard-only steps, markdown packs for claude-connectors, vercel-connect (Submit a Service values, OAuth method and token test), cursor and muse, and one sheet for the form-only directories. Also ard (a manifest for /.well-known/ard.json) and claude-eval (a "claude plugin eval" suite from the review tests). Returns the files written and any problems to fix first.',
+        inputSchema: {
+            project: PROJECT,
+            store: z.enum(PACKS),
+            tools_file: z.string().optional().describe('A saved tools/list result, relative to the project folder, for a server behind sign-in.'),
+        },
         annotations: { title: 'Pack', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    }, async ({ project, store }) => {
+    }, async ({ project, store, tools_file }) => {
         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 pack = await packFor(m, store, { token: token(), tools: tools_file, dir: dirOf(project) });
         const files = await writePack(pack, dirOf(project));
         return reply({ files, problems: pack.problems, todo: pack.todo });
     });
@@ -113,7 +124,7 @@ export async function serve() {
     }, async ({ project }) => reply({ links: tryLinks(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.',
+        description: 'Reads every store with a public record (MCP Registry, Claude connectors and plugins, Cursor, Grok, Glama, the awesome lists, Docker, Vercel Connect) 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 }) => {
@@ -157,7 +168,6 @@ export async function serve() {
    - 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.`));

package/dist/packs.d.ts

@@ -7,37 +7,67 @@ export interface Pack {
     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 listTools(m: Manifest, token?: string): Promise<Tool[]>;
+export interface PackOptions {
+    /** Access token for a server behind sign-in. */
+    token?: string;
+    /** A saved tools/list result to use instead of asking the server. */
+    tools?: string;
+    /** The folder holding mcplane.json, which local paths are relative to. */
+    dir?: string;
+}
+/** A saved tools/list: the result ({ "tools": [...] }), the whole JSON-RPC reply, or just the array. */
+export declare function parseToolsFile(text: string, file?: string): Tool[];
+/**
+ * The tool list a pack checks against: a saved file when given, else the live server. A pack that
+ * doesn't need the list to build (the ChatGPT ZIP, the Claude form) still builds when neither works.
+ */
+declare function toolsFor(m: Manifest, opts: PackOptions): Promise<{
+    tools: Tool[] | null;
+    why?: string;
+}>;
+/**
+ * OpenAI no longer asks for hint justifications: its automated review checks the hints and you appeal
+ * if it flags one. Justifications already written in mcplane.json are kept as notes for that appeal.
+ * With no tool list, every note is kept and the hint values are left out.
+ */
+declare function appealNotes(m: Manifest, tools: Tool[] | null): string;
 declare function category(raw?: string): string | null;
 /** WCAG contrast ratio between two #RRGGBB colours. */
 declare function contrast(a: string, b: string): number;
 /**
  * ChatGPT: the plugin ZIP the portal takes since DevDay (27 Sep 2026). plugin.json in the
  * Agent Plugins format carries the listing, the 5+3 test cases, demo video, release notes
- * and translations; mcp.json points at the server; icons are bundled. Reviewer credentials,
- * hint justifications and the policy attestations stay in the dashboard.
+ * and translations; mcp.json points at the server; icons are bundled. Reviewer credentials
+ * and the policy attestations stay in the dashboard.
+ */
+export declare function chatgptPack(m: Manifest, opts?: PackOptions): Promise<Pack>;
+export declare function claudePack(m: Manifest, opts?: PackOptions): Promise<Pack>;
+/**
+ * Vercel Connect: every value for Submit a Service, the OAuth method as Connect will discover it,
+ * and the token test each OAuth method needs before the form lets you submit.
+ * https://vercel.com/docs/connect/providers#submit-your-service-to-vercel-connect
+ */
+export declare function vercelConnectPack(m: Manifest): Promise<Pack>;
+/** ARD: one manifest for /.well-known/ard.json that Lighthouse 13.5 also accepts at ai-catalog.json. */
+export declare function ardPack(m: Manifest, opts?: PackOptions): Promise<Pack>;
+/**
+ * Claude Code plugin evals: mcplane.json's review tests as a "claude plugin eval" suite, with mocks
+ * from your live tools/list, to copy into the plugin repo.
+ * https://code.claude.com/docs/en/plugin-evals
  */
-export declare function chatgptPack(m: Manifest, token?: string): Promise<Pack>;
-export declare function claudePack(m: Manifest, token?: string): Promise<Pack>;
+export declare function claudeEvalPack(m: Manifest, opts?: PackOptions): Promise<Pack>;
+/** Every pack by name: a store with a form, or one of the extras. */
+export declare const PACKS: readonly ["chatgpt", "claude-connectors", "vercel-connect", "cursor", "muse", "directories", "ard", "claude-eval"];
+export declare function packFor(m: Manifest, name: string, opts?: PackOptions): 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;
+    appealNotes: typeof appealNotes;
     contrast: typeof contrast;
     category: typeof category;
+    toolsFor: typeof toolsFor;
 };
 export {};