mcplane 0.4.1 → 0.5.1

package/dist/cli.js

@@ -7,7 +7,7 @@ import { preflight } from './preflight.js';
 import { printPreflight } from './report.js';
 import { STORE_NAMES } from './types.js';
 import { recordDecision, recordSubmitted, status } from './submissions.js';
-import { chatgptPack, claudePack, directoriesPack, simplePack, writePack } from './packs.js';
+import { PACKS, packFor, writePack } from './packs.js';
 import { drift, printDrift, takeSnapshot } from './drift.js';
 import { publish } from './publish.js';
 import { lanes, runLane, tryLinks } from './extras.js';
@@ -23,18 +23,30 @@ Usage
       --verbose                       List passing checks too
       --register                      Also test OAuth client registration (writes test clients)
       --token <token>                 Access token for servers behind sign-in (or MCPLANE_TOKEN)
+      --sign-in <url>                 A sign-in page your consent screen uses, checked for bot walls (repeatable)
   mcplane submitted <store>           Record a submission and log it to Review Times
       --date YYYY-MM-DD --kind new|update|resubmission --version x.y.z
       --app-id asdk_app_...           ChatGPT: your app id, so its draft date is checked
       --private                       Keep it local; don't log to Review Times
   mcplane decided <store> approved|rejected|withdrawn [--date YYYY-MM-DD]
   mcplane status                      Every submission, how long it's waited, and the store's typical wait
-  mcplane pack <store>                Write a submission pack to .mcplane/packs (chatgpt, claude-connectors, cursor, muse, directories)
+  mcplane pack <store>                Write a submission pack to .mcplane/packs (chatgpt, claude-connectors, vercel-connect, cursor, muse, directories)
+      pack ard                        An ARD manifest for /.well-known/ard.json
+      pack claude-eval                A "claude plugin eval" suite from your review tests
+      --tools <file>                  A saved tools/list result, for servers behind sign-in (or pass --token)
   mcplane drift [--store <id>]...     What changed since each store saw your server, and what each needs
       --ci                            Exit 1 when a store needs a new version or an edit
   mcplane baseline <store> [--version x.y.z]   Record a listing that's already live as the drift baseline
   mcplane publish <store> [--yes]     Publish where the store allows it (mcp-registry, grok); dry run without --yes
   mcplane try                         Install links for every client, for you and your testers
+  mcplane demo                        Record the review demo video in ChatGPT desktop from your positive tests (macOS)
+      --only 1,3                      Which tests to record (default: all)
+      --out <file>                    Where to write it (default: .mcplane/packs/chatgpt/demo.mp4)
+      --approve                       Click "Allow once" when ChatGPT asks to run a tool
+      --plugin <name>                 The plugin to @mention, as ChatGPT names it (default: title)
+      --work                          Record in Work mode instead of Chat
+      --keep-open                     Leave ChatGPT running afterwards
+      --yes                           Don't ask before driving ChatGPT
   mcplane listings [--store <id>]...  Where you're listed, and whether what went live matches your server (--ci)
   mcplane lanes                       List lanes; run one with "mcplane <lane>" (built in: check, watch, release)
   mcplane fleet [--root <dir>]        Every project under a folder: blockers, store updates needed, reviews waiting
@@ -65,6 +77,8 @@ async function main() {
             verbose: { type: 'boolean' },
             register: { type: 'boolean' },
             token: { type: 'string' },
+            tools: { type: 'string' },
+            'sign-in': { type: 'string', multiple: true },
             date: { type: 'string' },
             kind: { type: 'string' },
             version: { type: 'string' },
@@ -74,6 +88,13 @@ async function main() {
             root: { type: 'string' },
             quick: { type: 'boolean' },
             yes: { type: 'boolean' },
+            only: { type: 'string' },
+            out: { type: 'string' },
+            approve: { type: 'boolean' },
+            plugin: { type: 'string' },
+            work: { type: 'boolean' },
+            'keep-open': { type: 'boolean' },
+            port: { type: 'string' },
         },
         allowPositionals: true,
     });
@@ -108,6 +129,8 @@ async function main() {
     }
     if (cmd === 'preflight') {
         const m = values.url ? await draftManifest(values.url) : await loadManifest();
+        if (values['sign-in']?.length)
+            m.server.signIn = [...(m.server.signIn ?? []), ...values['sign-in']];
         const stores = (values.store ?? []);
         for (const s of stores)
             if (!(s in STORE_NAMES))
@@ -140,11 +163,13 @@ async function main() {
     }
     if (cmd === 'pack') {
         const m = await loadManifest();
-        const store = positionals[0] === 'directories' ? null : asStore(positionals[0]);
-        const token = values.token ?? process.env.MCPLANE_TOKEN;
-        const pack = !store ? directoriesPack(m) : store === 'chatgpt' ? await chatgptPack(m, token) : store === 'claude-connectors' ? await claudePack(m, token) : await simplePack(m, store);
+        const name = positionals[0];
+        if (!PACKS.includes(name))
+            asStore(name);
+        const pack = await packFor(m, name, { token: values.token ?? process.env.MCPLANE_TOKEN, tools: values.tools });
         const written = await writePack(pack);
-        console.log(`Wrote ${written.join(', ')}`);
+        const dirs = [...new Set(written.map((w) => w.split('/').slice(0, 3).join('/')))];
+        console.log(written.length > 6 ? `Wrote ${written.length} files under ${dirs.join(', ')}/` : `Wrote ${written.join(', ')}`);
         if (pack.problems.length) {
             console.log('\nFix before submitting:');
             for (const p of pack.problems)
@@ -226,6 +251,29 @@ async function main() {
             console.log(`${t.client.padEnd(22)} ${t.how}`);
         return;
     }
+    if (cmd === 'demo') {
+        const m = await loadManifest();
+        if (values.port && !/^\d+$/.test(values.port))
+            throw new Error('--port takes a port number, e.g. 9333.');
+        const { demo } = await import('./demo.js');
+        const r = await demo(m, {
+            only: values.only,
+            out: values.out,
+            approve: values.approve,
+            plugin: values.plugin,
+            work: values.work,
+            keepOpen: values['keep-open'],
+            yes: values.yes,
+            port: values.port ? Number(values.port) : undefined,
+            token: values.token ?? process.env.MCPLANE_TOKEN,
+        });
+        const mins = Math.floor(r.seconds / 60);
+        console.log(`\nWrote ${r.out} (${r.scenes} scene${r.scenes === 1 ? '' : 's'}, ${mins ? `${mins}m ` : ''}${Math.round(r.seconds % 60)}s).`);
+        for (const n of r.notes)
+            console.log(`  ! ${n}`);
+        console.log('Watch it, upload it where a reviewer can open it without signing in, set chatgpt.demoVideo to that URL, then run "mcplane pack chatgpt".');
+        return;
+    }
     if (cmd === 'listings' || cmd === 'pull') {
         const m = await loadManifest();
         const stores = (values.store?.length ? values.store : storesOf(m));

package/dist/core.d.ts

@@ -14,5 +14,6 @@ export declare function preflight(m: Manifest, opts?: {
 }): Promise<PreflightResult>;
 export { draftManifest, forStore, storesOf, SCHEMA_URL } from './draft.js';
 export { toolChecks } from './checks/tools.js';
+export { validateArd, ardManifest } from './checks/ard.js';
 export { STORE_NAMES } from './types.js';
 export type { Check, Level, Manifest, StoreId, Tool } from './types.js';

package/dist/core.js

@@ -2,10 +2,15 @@
  * mcplane's checks for any runtime with fetch (Workers, Deno, browsers' servers).
  * Import from "mcplane/core".
  */
+import { ardChecks } from './checks/ard.js';
 import { authChecks } from './checks/auth.js';
+import { chainChecks } from './checks/chain.js';
 import { listingChecks, repoChecks } from './checks/listing.js';
+import { discover } from './checks/oauth.js';
+import { readinessChecks } from './checks/readiness.js';
 import { serverChecks } from './checks/server.js';
 import { toolChecks } from './checks/tools.js';
+import { VERCEL_REMINDERS, vercelChecks } from './checks/vercel.js';
 import { storesOf } from './draft.js';
 /** Things no script can see, which have still cost real submissions. */
 function reminders(m, stores) {
@@ -18,10 +23,10 @@ function reminders(m, stores) {
         r.push('If a tool writes somewhere public (posts, sends, publishes), give reviewers a safe target: a sandbox account or a "playground" option that validates and then discards. Reviewers test writes; they shouldn’t post to a real timeline.');
     }
     if (stores.includes('chatgpt')) {
-        r.push('ChatGPT needs a demo video recorded in developer mode that shows the tools your test cases use. Re-record it whenever tools change.');
+        r.push('ChatGPT needs a demo video recorded in developer mode that shows the tools your test cases use. Re-record it whenever tools change ("mcplane demo" records it on a Mac with ChatGPT desktop).');
         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.');
+        r.push('OpenAI no longer asks for hint justifications: its automated review checks each tool’s hints. If it flags one you believe is right, appeal with an explanation.');
+        r.push('ChatGPT allows one version in review at a time, and a rescan doesn’t update the tools it was submitted with. To change a submission, Cancel Review (back to Draft), reconnect if tools changed so ChatGPT rediscovers them, and resubmit.');
     }
     if (stores.includes('claude-connectors') || stores.includes('claude-plugins')) {
         if (stores.includes('claude-connectors'))
@@ -30,6 +35,8 @@ function reminders(m, stores) {
             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.');
     }
+    if (stores.includes('vercel-connect') && m.server.auth === 'oauth')
+        r.push(...VERCEL_REMINDERS);
     return r;
 }
 /** Runtime-neutral: fetch only. Node adds socket checks (TLS 1.2) through extraChecks; see preflight-node. */
@@ -37,16 +44,25 @@ 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, opts.extraChecks);
-    const [authC, listing, repo] = await Promise.all([
+    // One read of the OAuth discovery documents, shared by the sign-in chain, Vercel Connect and readiness checks.
+    const oauth = auth === 'oauth' ? await discover(m.server.url).catch(() => null) : null;
+    // A server that doesn't answer at all has already failed; probing it for the next revision adds nothing.
+    const down = server.checks.some((c) => c.id === 'server.reachable' && c.level === 'fail');
+    const [authC, chain, listing, repo, ard, readiness] = await Promise.all([
         auth === 'oauth' ? authChecks(m.server.url, { register: opts.register }) : Promise.resolve([]),
+        auth === 'oauth' ? chainChecks(m, oauth).catch(() => []) : Promise.resolve([]),
         listingChecks(m, server.tools, stores),
         repoChecks(m, stores),
+        ardChecks(m),
+        down ? Promise.resolve([]) : readinessChecks(m.server.url, auth, { token: opts.token, oauth }),
     ]);
-    const all = [...server.checks, ...authC, ...toolChecks(server.tools), ...listing, ...repo];
+    const vercel = stores.includes('vercel-connect') ? vercelChecks(m, oauth) : [];
+    const all = [...server.checks, ...authC, ...chain, ...toolChecks(server.tools), ...listing, ...repo, ...vercel, ...ard, ...readiness];
     // 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 };
 }
 export { draftManifest, forStore, storesOf, SCHEMA_URL } from './draft.js';
 export { toolChecks } from './checks/tools.js';
+export { validateArd, ardManifest } from './checks/ard.js';
 export { STORE_NAMES } from './types.js';

package/dist/demo.d.ts

@@ -0,0 +1,60 @@
+import type { Manifest } from './types.js';
+/**
+ * Every label mcplane relies on in ChatGPT desktop (checked against 26.903, 1 October 2026).
+ * When a release renames something, this is the one place to fix.
+ */
+export declare const UI: {
+    hideSidebar: string;
+    showSidebar: string;
+    newChat: string;
+    chatMode: string;
+    workMode: string;
+    addMenu: string;
+    send: string[];
+    stop: string[];
+    /** Buttons on a tool approval card. */
+    approval: string[];
+    /** What --approve clicks, first match wins. Never "Always allow": a demo shouldn't change your settings. */
+    allow: string[];
+    /** The collapsed summary of tool calls ("Worked for 5s"), opened at the end of each scene. */
+    activity: string;
+    signIn: string[];
+    /** Part of the message box's accessible name: "Message ChatGPT", "Ask ChatGPT", "Work with ChatGPT". */
+    composer: string;
+    /** The @mention pill keeps the plugin's id here; developer-mode plugins are "created-by-me". */
+    mentionAttr: string;
+    devMode: string;
+};
+/** "1,3" or "2-4" to zero-based indexes into the positive tests, in the order given. */
+export declare function pickTests(count: number, only?: string): number[];
+export interface DemoOptions {
+    /** Positive tests to record, e.g. "1,3" (default: all). */
+    only?: string;
+    /** Where to write the video (default: .mcplane/packs/chatgpt/demo.mp4). */
+    out?: string;
+    /** Click "Allow once" on tool approval cards. */
+    approve?: boolean;
+    /** Leave ChatGPT running afterwards (it keeps its debugging port open until you quit it). */
+    keepOpen?: boolean;
+    /** Don't ask first. */
+    yes?: boolean;
+    /** The plugin to @mention (default: the manifest's title). */
+    plugin?: string;
+    /** Record in Work mode instead of Chat. */
+    work?: boolean;
+    port?: number;
+    token?: string;
+    dir?: string;
+    log?: (line: string) => void;
+}
+export interface DemoResult {
+    out: string;
+    seconds: number;
+    scenes: number;
+    notes: string[];
+}
+export declare function demo(m: Manifest, o?: DemoOptions): Promise<DemoResult>;
+export declare const _test: {
+    pickTests: typeof pickTests;
+    PAGE: string;
+};