mcplane 0.3.1 → 0.4.1

package/README.md

@@ -72,7 +72,7 @@ npx mcplane fleet --root ~/Projects
 |---|---|---|
 | Official MCP Registry | **Publishes**: writes `server.json`, runs `mcp-publisher`, signs in with GitHub OIDC in Actions. Glama and PulseMCP import from it; GitHub's MCP gallery (VS Code) syncs it after a one-time manual onboarding | Versions can't change: bump, or a prerelease like `1.2.0-1` for listing-only edits. mcplane checks what's already published |
 | Grok plugins | **Publishes**: opens the pull request to `xai-org/plugin-marketplace`, validated with xAI's own scripts | Opens a pin-bump PR when xAI's daily bump lags |
-| ChatGPT | **Prepares** `chatgpt-app-submission.json` for the portal's import: listing, tools, hint justifications, 5+3 tests | Tool changes roll out after OpenAI's automated checks. Listing text and hint justifications need a new version, and drift says when |
+| ChatGPT | **Builds the plugin ZIP** the portal uploads since DevDay: `plugin.json` (Agent Plugins format) with listing, icons, 5+3 tests, demo video, release notes and translations, plus `mcp.json`. Checked against OpenAI's submission rules | Tool changes roll out after OpenAI's scans. Listing changes need a new ZIP and review, and drift says when |
 | Claude connectors | **Prepares** every field of the directory form | Tool changes are live on deploy; listing edits (tool names included) are reviewed |
 | Claude plugins | **Prepares** and checks the plugin repo | The portal tracks your branch; drift tells you a new version is waiting for review |
 | Cursor | **Prepares** and checks the plugin repo | Pinned to the commit first added; drift flags when you've moved on |
@@ -122,6 +122,21 @@ A form that returned 200 is a claim; the public record is the result. `listings`
 
 Coverage decays quietly, so run it on a schedule (`--ci` exits 1 on a mismatch). `fleet` runs it for every project.
 
+## ChatGPT's plugin ZIP
+
+Since DevDay (September 2026) ChatGPT takes a plugin ZIP. `mcplane pack chatgpt` builds it from `mcplane.json`: `plugin.json` in the Agent Plugins format, with listing, icons, the 5 positive and 3 negative test cases, demo video, release notes and translations, plus `mcp.json`. It checks the package against OpenAI's submission rules first: name and description lengths, category, the four https URLs, at most 3 starter prompts, square icons of 48 to 4096 px, brand-colour contrast.
+
+```json
+"chatgpt": {
+  "demoVideo": "https://example.com/demo.mp4",
+  "releaseNotes": "Adds hourly forecasts.",
+  "capabilities": ["Search forecasts", "Compare cities"],
+  "brandColor": "#2357C6"
+}
+```
+
+What stays with you: upload the ZIP, enter reviewer credentials and the per-tool hint justifications (drafted in `chatgpt.md`), and make the attestations. Bump `version` for every upload. Tool changes don't need a new ZIP; OpenAI's scans pick them up, and `drift` tracks extension metadata (sidebar, panels, file viewers) as part of each tool.
+
 ## Keeping listings current
 
 Every store calls your live server, so fixes reach users on their own. What doesn't: listing text, tool names in Claude's listing, ChatGPT's hint justifications, registry versions and plugins pinned to a commit. Each store has different rules for these. When you record a submission, mcplane snapshots what the store is reviewing. `mcplane drift` compares your live server and `mcplane.json` against that snapshot and tells you what each store needs.
@@ -237,6 +252,18 @@ It's what powers [reviewtimes.fyi/check](https://reviewtimes.fyi/check). The TLS
 
 One file describes your server and its listings. [`schema.json`](schema.json) gives editors completion and validation; `mcplane init` adds the `$schema` line. [`examples/mcplane.json`](examples/mcplane.json) is a complete one, from [Review Times](https://reviewtimes.fyi)' own ChatGPT and Claude submissions.
 
+
+Each store can have its own listing text, the way fastlane keeps metadata per language. Anything you leave out falls back to the shared fields:
+
+```json
+"description": "Shows how long AI app stores are taking to review submissions…",
+"listing": {
+  "claude-connectors": { "description": "Ask Claude before you submit (\"How long is Claude plugin review taking?\")…" }
+}
+```
+
+Packs, checks, `drift` and `listings` all use the right text for each store.
+
 ## fastlane, mapped
 
 | fastlane | mcplane |

package/dist/checks/listing.js

@@ -1,3 +1,4 @@
+import { forStore } from '../draft.js';
 const get = (url) => fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(12_000), headers: { 'user-agent': 'mcplane' } }).catch(() => null);
 /** Width and height from a PNG's IHDR chunk. */
 function pngSize(buf) {
@@ -89,23 +90,32 @@ export async function listingChecks(m, tools, stores) {
             checks.push({ id, level: 'pass', title: `${label} fits (${max} characters)`, stores: s });
     };
     if (has(stores, 'chatgpt')) {
-        len(m.title, 30, 'listing.name', 'Display name', ['chatgpt']);
-        len(m.subtitle, 30, 'listing.subtitle', 'Subtitle', ['chatgpt']);
-        const prompts = m.prompts ?? [];
+        const g = forStore(m, 'chatgpt');
+        len(g.title, 30, 'listing.name', 'Display name', ['chatgpt']);
+        len(g.subtitle, 30, 'listing.subtitle', 'Subtitle', ['chatgpt']);
+        const prompts = g.prompts ?? [];
         const bad = prompts.filter((p) => p.length > 128 || /(^|\s)@\w/.test(p));
+        if (prompts.length > 3)
+            bad.push(`${prompts.length} prompts (at most 3)`);
         const dupes = prompts.filter((p, i) => prompts.findIndex((q) => q.trim().toLowerCase() === p.trim().toLowerCase()) !== i);
         if (bad.length || dupes.length) {
-            checks.push({ id: 'listing.prompts', level: 'fail', title: 'Starter prompts are short, unique and free of @mentions', detail: [...bad.map((p) => `"${p.slice(0, 40)}…"`), ...dupes.map((p) => `duplicate: "${p.slice(0, 40)}"`)].join('; '), fix: 'ChatGPT rejects starter prompts over 128 characters, with @mentions, or repeated.', stores: ['chatgpt'] });
+            checks.push({ id: 'listing.prompts', level: 'fail', title: 'Starter prompts are short, unique and free of @mentions', detail: [...bad.map((p) => `"${p.slice(0, 40)}…"`), ...dupes.map((p) => `duplicate: "${p.slice(0, 40)}"`)].join('; '), fix: 'ChatGPT takes at most 3 starter prompts, each one line of up to 128 characters, unique, with no @mentions.', stores: ['chatgpt'] });
         }
         else if (prompts.length) {
             checks.push({ id: 'listing.prompts', level: 'pass', title: 'Starter prompts are short, unique and free of @mentions', stores: ['chatgpt'] });
         }
+        len(g.description, 4000, 'listing.chatgpt-description', 'Long description for ChatGPT', ['chatgpt']);
+        // The plugin package requires all four listing URLs for MCP review.
+        const missing = ['website', 'support', 'privacy', 'terms'].filter((k) => !g.links?.[k]?.startsWith('https://'));
+        checks.push(missing.length
+            ? { id: 'listing.chatgpt-urls', level: 'fail', title: 'Website, support, privacy and terms URLs are set', detail: `missing or not https: ${missing.join(', ')}`, fix: 'ChatGPT’s plugin package requires all four as https URLs for MCP review.', stores: ['chatgpt'] }
+            : { id: 'listing.chatgpt-urls', level: 'pass', title: 'Website, support, privacy and terms URLs are set', stores: ['chatgpt'] });
     }
     if (has(stores, 'claude-connectors', 'claude-plugins'))
-        len(m.title, 100, 'listing.claude-name', 'Name for Claude', ['claude-connectors', 'claude-plugins']);
+        len(forStore(m, 'claude-connectors').title, 100, 'listing.claude-name', 'Name for Claude', ['claude-connectors', 'claude-plugins']);
     if (has(stores, 'claude-connectors', 'claude-plugins'))
-        len(m.oneLiner, 200, 'listing.one-liner', 'One-liner', ['claude-connectors', 'claude-plugins']);
-    len(m.description, 2000, 'listing.description', 'Description', []);
+        len(forStore(m, 'claude-connectors').oneLiner, 200, 'listing.one-liner', 'One-liner', ['claude-connectors', 'claude-plugins']);
+    len(forStore(m, 'claude-connectors').description, 2000, 'listing.description', 'Description', []);
     // Test cases must name tools the server actually has; descriptions drift away from live servers.
     const named = [...new Set((m.tests?.positive ?? []).flatMap((t) => t.tools))];
     if (tools.length && named.length) {

package/dist/checks/tools.js

@@ -118,5 +118,9 @@ export function toolChecks(tools) {
     checks.push(upsell.length
         ? { id: 'tools.no-upsell', level: 'fail', title: 'No upgrade or pricing copy in tools', detail: upsell.map((t) => t.name).join(', '), fix: 'OpenAI prohibits in-app commerce for digital subscriptions, including freemium upsells. Keep plans and pricing on your site; tool text and errors should not steer users to upgrade.', stores: ['chatgpt'] }
         : { id: 'tools.no-upsell', level: 'pass', title: 'No upgrade or pricing copy in tools' });
+    // ChatGPT extensions (DevDay 2026): entrypoints declared in _meta["openai/ui"]. Reported so they show up in reviews and drift.
+    const ext = tools.flatMap((t) => ((t._meta?.['openai/ui']?.entrypoints) ?? []).map((e) => `${t.name}: ${e.type}${e.extensions?.length ? ` (${e.extensions.join(', ')})` : ''}`));
+    if (ext.length)
+        checks.push({ id: 'tools.extensions', level: 'pass', title: 'ChatGPT extensions declared', detail: ext.join('; '), stores: ['chatgpt'] });
     return checks;
 }

package/dist/core.d.ts

@@ -12,7 +12,7 @@ export declare function preflight(m: Manifest, opts?: {
     token?: string;
     extraChecks?: SocketCheck[];
 }): Promise<PreflightResult>;
-export { draftManifest, storesOf, SCHEMA_URL } from './draft.js';
+export { draftManifest, forStore, storesOf, SCHEMA_URL } from './draft.js';
 export { toolChecks } from './checks/tools.js';
 export { STORE_NAMES } from './types.js';
 export type { Check, Level, Manifest, StoreId, Tool } from './types.js';

package/dist/core.js

@@ -47,6 +47,6 @@ export async function preflight(m, opts = {}) {
     const checks = all.filter((c) => !c.stores?.length || c.stores.some((s) => stores.includes(s)));
     return { checks, reminders: reminders(m, stores), stores };
 }
-export { draftManifest, storesOf, SCHEMA_URL } from './draft.js';
+export { draftManifest, forStore, storesOf, SCHEMA_URL } from './draft.js';
 export { toolChecks } from './checks/tools.js';
 export { STORE_NAMES } from './types.js';

package/dist/draft.d.ts

@@ -1,5 +1,7 @@
 import { type Manifest, type StoreId } from './types.js';
 export declare const SCHEMA_URL = "https://unpkg.com/mcplane/schema.json";
+/** The manifest as one store sees it: that store's listing text over the shared fields. */
+export declare function forStore(m: Manifest, store: StoreId): Manifest;
 export declare function storesOf(m: Manifest): StoreId[];
 /** A starting manifest from what the live server and its domain reveal. */
 export declare function draftManifest(url: string): Promise<Manifest>;

package/dist/draft.js

@@ -2,6 +2,14 @@
 import { McpClient } from './mcp-client.js';
 import { STORE_NAMES } from './types.js';
 export const SCHEMA_URL = 'https://unpkg.com/mcplane/schema.json';
+/** The manifest as one store sees it: that store's listing text over the shared fields. */
+export function forStore(m, store) {
+    const o = m.listing?.[store];
+    if (!o)
+        return m;
+    const set = Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined && v !== ''));
+    return { ...m, ...set };
+}
 export function storesOf(m) {
     return m.stores?.length ? m.stores : Object.keys(STORE_NAMES);
 }

package/dist/drift.d.ts

@@ -10,6 +10,8 @@ interface ToolShape {
     };
     input: string;
     output: string;
+    /** UI and extension metadata (entrypoints, resource URIs), when the tool declares any. */
+    ui?: string;
 }
 export interface Snapshot {
     store: StoreId;

package/dist/drift.js

@@ -11,6 +11,7 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { ensureLocalDir } from './manifest.js';
+import { forStore } from './draft.js';
 import { McpClient } from './mcp-client.js';
 import { STORE_NAMES } from './types.js';
 const DIR = '.mcplane/snapshots';
@@ -21,6 +22,12 @@ function canon(v) {
     const sort = (x) => (Array.isArray(x) ? x.map(sort) : x && typeof x === 'object' ? Object.fromEntries(Object.keys(x).sort().map((k) => [k, sort(x[k])])) : x);
     return JSON.stringify(sort(v));
 }
+/** The parts of _meta that put a tool on screen: MCP Apps UI, ChatGPT extension entrypoints, output templates. */
+function uiOf(t) {
+    const m = t._meta ?? {};
+    const picked = Object.fromEntries(Object.entries({ ui: m.ui, openai: m['openai/ui'], template: m['openai/outputTemplate'] }).filter(([, v]) => v !== undefined));
+    return Object.keys(picked).length ? canon(picked) : '';
+}
 function shape(t) {
     return {
         name: t.name,
@@ -29,6 +36,7 @@ function shape(t) {
         hints: { readOnly: t.annotations?.readOnlyHint, destructive: t.annotations?.destructiveHint, openWorld: t.annotations?.openWorldHint },
         input: canon(t.inputSchema),
         output: canon(t.outputSchema),
+        ui: uiOf(t),
     };
 }
 function listingOf(m) {
@@ -69,7 +77,7 @@ export async function takeSnapshot(m, store, opts, dir = process.cwd()) {
         version: opts.version,
         state: opts.state,
         tools: tools.map(shape),
-        listing: listingOf(m),
+        listing: listingOf(forStore(m, store)),
         repoSha,
     };
     await ensureLocalDir(dir);
@@ -111,6 +119,9 @@ export function diffTools(before, now) {
             fields.push('inputs');
         if (o.output !== t.output)
             fields.push('outputSchema');
+        // Snapshots from before 0.4 have no ui field; don't report that as a change.
+        if (o.ui !== undefined && o.ui !== t.ui)
+            fields.push('UI/extensions');
         if ((o.title ?? '') !== (t.title ?? ''))
             fields.push('title');
         if ((o.description ?? '') !== (t.description ?? ''))
@@ -131,8 +142,8 @@ export async function drift(m, stores, opts = {}, dir = process.cwd()) {
     const missing = [];
     const [live, head] = await Promise.all([liveTools(m, opts.token), repoHead(m.repository)]);
     const now = live.map(shape);
-    const listing = listingOf(m);
     for (const store of stores) {
+        const listing = listingOf(forStore(m, store));
         const snap = await readSnapshot(store, dir);
         if (!snap) {
             missing.push(store);

package/dist/extras.js

@@ -18,7 +18,7 @@ export const DEFAULT_LANES = {
         '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: 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: 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/listings.js

@@ -4,6 +4,7 @@
  * public record is the result. Coverage decays quietly, so this is meant to
  * run on a schedule.
  */
+import { forStore } from './draft.js';
 import { liveTools, repoHead } from './drift.js';
 import { registryName } from './publish.js';
 import { STORE_NAMES } from './types.js';
@@ -44,6 +45,7 @@ async function registry(m) {
     return { store: 'mcp-registry', state: 'listed', url: `https://registry.modelcontextprotocol.io/v0/servers?search=${encodeURIComponent(name)}`, issues };
 }
 async function claudeConnectors(m, token) {
+    m = forStore(m, 'claude-connectors');
     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.' };
@@ -52,9 +54,9 @@ async function claudeConnectors(m, token) {
         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');
+        issues.push('one-liner differs from mcplane.json (edit the listing, or set listing["claude-connectors"] if the difference is intended)');
     if (m.description && norm(hit.description) !== norm(m.description))
-        issues.push('description differs from mcplane.json');
+        issues.push('description differs from mcplane.json (edit the listing, or set listing["claude-connectors"] if the difference is intended)');
     // 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);
@@ -105,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: [] };

package/dist/manifest.d.ts

@@ -1,5 +1,5 @@
 import { type Manifest } from './types.js';
-export { draftManifest, storesOf } from './draft.js';
+export { draftManifest, forStore, 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>;

package/dist/manifest.js

@@ -1,7 +1,7 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { STORE_NAMES } from './types.js';
-export { draftManifest, storesOf } from './draft.js';
+export { draftManifest, forStore, storesOf } from './draft.js';
 export const MANIFEST_FILE = 'mcplane.json';
 export { SCHEMA_URL } from './draft.js';
 export async function loadManifest(dir = process.cwd()) {

package/dist/mcp-server.js

@@ -53,7 +53,7 @@ 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: 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.',
+        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']) },
         annotations: { title: 'Pack', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async ({ project, store }) => {

package/dist/packs.d.ts

@@ -2,7 +2,7 @@ import type { Manifest, StoreId, Tool } from './types.js';
 export interface Pack {
     files: {
         path: string;
-        content: string;
+        content: string | Uint8Array;
     }[];
     problems: string[];
     todo: string[];
@@ -19,6 +19,15 @@ declare function justify(t: Tool, product: string, own?: {
     open_world_justification: string;
     destructive_justification: 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.
+ */
 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>;
@@ -28,5 +37,7 @@ export declare function writePack(pack: Pack, dir?: string): Promise<string[]>;
 export declare const _test: {
     thirdPerson: typeof thirdPerson;
     justify: typeof justify;
+    contrast: typeof contrast;
+    category: typeof category;
 };
 export {};

package/dist/packs.js

@@ -1,14 +1,14 @@
 /**
- * Submission packs: everything a store's form asks for, in its order, checked
- * against its limits. ChatGPT gets the chatgpt-app-submission.json its portal
- * imports (the format OpenAI's own chatgpt-app-submission skill writes); the
- * rest get a markdown pack to paste from.
+ * Submission packs: everything a store asks for, checked against its limits.
+ * ChatGPT gets the plugin ZIP its portal uploads; the rest get a markdown pack
+ * to paste from.
  */
 import { mkdir, writeFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
+import { dirname, resolve } from 'node:path';
 import { ensureLocalDir } from './manifest.js';
+import { forStore } from './draft.js';
 import { McpClient } from './mcp-client.js';
-const CATEGORIES = ['BUSINESS', 'COLLABORATION', 'DESIGN', 'DEVELOPER_TOOLS', 'EDUCATION', 'ENTERTAINMENT', 'FINANCE', 'FOOD', 'LIFESTYLE', 'NEWS', 'PRODUCTIVITY', 'SHOPPING', 'TRAVEL'];
+import { zip } from './zip.js';
 const MAX_JUSTIFICATION = 200; // the ChatGPT form cuts longer ones without warning
 async function listTools(m, token) {
     const c = new McpClient(m.server.url, token ? { authorization: `Bearer ${token}` } : {});
@@ -45,34 +45,105 @@ function justify(t, product, own) {
             (a.destructiveHint ? `Can delete or overwrite data: it ${what}.` : a.readOnlyHint ? 'Read-only, so it cannot delete or overwrite anything.' : 'Only adds or updates the user’s own data; it never deletes or overwrites existing records.'), MAX_JUSTIFICATION),
     };
 }
+/** The categories ChatGPT's package validator accepts, and the old form's names mapped onto them. */
+const CATEGORIES = ['Productivity', 'Creativity', 'Developer Tools', 'Business & Operations', 'Data & Analytics', 'Communication', 'Education & Research', 'Security', 'Finance', 'Healthcare', 'Travel', 'Entertainment', 'Other'];
+const OLD_CATEGORY = {
+    BUSINESS: 'Business & Operations', COLLABORATION: 'Communication', DESIGN: 'Creativity', DEVELOPER_TOOLS: 'Developer Tools', EDUCATION: 'Education & Research',
+    ENTERTAINMENT: 'Entertainment', FINANCE: 'Finance', PRODUCTIVITY: 'Productivity', TRAVEL: 'Travel', FOOD: 'Other', LIFESTYLE: 'Other', NEWS: 'Other', SHOPPING: 'Other',
+};
+function category(raw) {
+    if (!raw)
+        return null;
+    const hit = CATEGORIES.find((c) => c.toLowerCase() === raw.toLowerCase());
+    return hit ?? OLD_CATEGORY[raw.toUpperCase().replace(/[^A-Z]+/g, '_')] ?? null;
+}
+/** WCAG contrast ratio between two #RRGGBB colours. */
+function contrast(a, b) {
+    const lum = (hex) => {
+        const [r, g, bl] = [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255).map((c) => (c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4));
+        return 0.2126 * r + 0.7152 * g + 0.0722 * bl;
+    };
+    const [x, y] = [lum(a), lum(b)].sort((p, q) => q - p);
+    return (x + 0.05) / (y + 0.05);
+}
+/** Downloads an icon and checks it against the package rules: square, 48 to 4096 px, 5 MiB, PNG/JPEG/WebP/SVG. */
+async function fetchIcon(url, label, problems) {
+    const res = await fetch(url, { headers: { 'user-agent': 'mcplane' } }).catch(() => null);
+    if (!res?.ok) {
+        problems.push(`${label} ${url} didn't load (HTTP ${res?.status ?? 'error'})`);
+        return null;
+    }
+    const type = res.headers.get('content-type') ?? '';
+    const data = new Uint8Array(await res.arrayBuffer());
+    const ext = type.includes('svg') || url.endsWith('.svg') ? 'svg' : type.includes('jpeg') || /\.jpe?g$/.test(url) ? 'jpg' : type.includes('webp') || url.endsWith('.webp') ? 'webp' : 'png';
+    if (data.length > 5 * 1024 * 1024)
+        problems.push(`${label} is ${(data.length / 1048576).toFixed(1)} MiB; the limit is 5 MiB`);
+    if (ext === 'png' && data[0] === 0x89) {
+        const v = new DataView(data.buffer, data.byteOffset);
+        const [w, h] = [v.getUint32(16), v.getUint32(20)];
+        if (w !== h)
+            problems.push(`${label} is ${w}×${h}; it must be square`);
+        else if (w < 48 || w > 4096)
+            problems.push(`${label} is ${w} px; it must be 48 to 4096 px`);
+    }
+    return { data, ext };
+}
+/**
+ * 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.
+ */
 export async function chatgptPack(m, token) {
+    m = forStore(m, 'chatgpt');
+    const g = m.chatgpt ?? {};
     const tools = await listTools(m, token);
     const problems = [];
     const todo = [];
-    const category = (m.category ?? '').toUpperCase().replace(/[^A-Z]+/g, '_');
-    if (!CATEGORIES.includes(category))
-        problems.push(`category "${m.category ?? ''}" isn't one of ChatGPT's: ${CATEGORIES.join(', ')}`);
-    if ((m.subtitle ?? '').length > 30)
-        problems.push(`subtitle is ${m.subtitle.length} characters; the limit is 30`);
-    if (!m.subtitle)
-        problems.push('subtitle is missing (30 characters, a plain functional phrase)');
+    const need = (ok, msg) => {
+        if (!ok)
+            problems.push(msg);
+    };
+    const oneLine = (v, max, label) => {
+        need(v, `${label} is missing`);
+        if (v && v.length > max)
+            problems.push(`${label} is ${v.length} characters; the limit is ${max}`);
+        if (v && /\n/.test(v))
+            problems.push(`${label} must be one line`);
+    };
+    need(/^[a-z0-9]+(-[a-z0-9]+)*$/.test(m.name) && m.name.length <= 64, `name "${m.name}" must be lowercase letters, digits and single hyphens, at most 64 characters`);
+    need(m.version && /^\d+\.\d+\.\d+/.test(m.version), 'version must be a semantic version (e.g. 1.0.0); every upload needs a new one');
+    oneLine(m.title, 30, 'Display name (title)');
+    oneLine(m.subtitle, 30, 'Short description (subtitle)');
+    need(m.description, 'Long description is missing');
+    if ((m.description ?? '').length > 4000)
+        problems.push(`Long description is ${m.description.length} characters; the limit is 4000`);
+    const developerName = g.developerName ?? m.author?.name;
+    oneLine(developerName, 80, 'Developer name (chatgpt.developerName or author.name)');
+    const cat = category(m.category);
+    need(cat, `category "${m.category ?? ''}" isn't one of: ${CATEGORIES.join(', ')}`);
+    for (const [k, v] of Object.entries({ website: m.links?.website, support: m.links?.support, privacy: m.links?.privacy, terms: m.links?.terms }))
+        need(v && v.startsWith('https://'), `links.${k} must be an https URL (all four are required for review)`);
+    const prompts = m.prompts ?? [];
+    if (prompts.length > 3)
+        problems.push(`${prompts.length} starter prompts; the limit is 3`);
+    for (const p of prompts)
+        if (p.length > 128 || /\n/.test(p) || /(^|\s)@\w/.test(p))
+            problems.push(`starter prompt "${p.slice(0, 40)}…" must be one line, at most 128 characters, with no @mention`);
+    for (const c of g.capabilities ?? [])
+        if (c.length > 120)
+            problems.push(`capability "${c.slice(0, 40)}…" is over 120 characters`);
+    if ((g.capabilities ?? []).length > 20)
+        problems.push('at most 20 capabilities');
+    if (g.brandColor && (!/^#[0-9a-fA-F]{6}$/.test(g.brandColor) || contrast(g.brandColor, '#FFFFFF') < 2))
+        problems.push(`brandColor ${g.brandColor} needs 2:1 contrast against white`);
+    if (g.brandColorDark && (!/^#[0-9a-fA-F]{6}$/.test(g.brandColorDark) || contrast(g.brandColorDark, '#212121') < 2))
+        problems.push(`brandColorDark ${g.brandColorDark} needs 2:1 contrast against #212121`);
+    need(g.demoVideo, 'chatgpt.demoVideo is missing: a reviewer-accessible video URL showing the main use cases (required for review)');
+    need(g.releaseNotes, 'chatgpt.releaseNotes is missing (required for review)');
     const missingHints = tools.filter((t) => ['readOnlyHint', 'openWorldHint', 'destructiveHint'].some((h) => typeof t.annotations?.[h] !== 'boolean'));
     for (const t of missingHints)
         problems.push(`${t.name} doesn't set all three hints; ChatGPT treats that as a blocker`);
-    const toolsOut = Object.fromEntries(tools.map((t) => [
-        t.name,
-        {
-            annotations: {
-                readOnlyHint: !!t.annotations?.readOnlyHint,
-                openWorldHint: !!t.annotations?.openWorldHint,
-                destructiveHint: !!t.annotations?.destructiveHint,
-            },
-            justifications: justify(t, m.title, m.justifications?.[t.name]),
-        },
-    ]));
-    const drafted = tools.filter((t) => !m.justifications?.[t.name]).map((t) => t.name);
-    if (drafted.length)
-        todo.push(`Read the drafted justifications for ${drafted.join(', ')}: they come from your hints and tool descriptions. Once they say exactly what each tool changes, save them under "justifications" in mcplane.json so every version reuses them.`);
     for (const [name, j] of Object.entries(m.justifications ?? {}))
         for (const [k, v] of Object.entries(j))
             if (v && v.length > MAX_JUSTIFICATION)
@@ -92,54 +163,115 @@ export async function chatgptPack(m, token) {
     for (const t of tools)
         if (!covered.has(t.name))
             todo.push(`No positive test uses ${t.name}. Reviewers check every tool.`);
-    const json = {
-        $schema: 'https://developers.openai.com/apps-sdk/schemas/chatgpt-app-submission.v1.json',
-        schema_version: 1,
-        app_info: { display_name: m.title, subtitle: m.subtitle ?? '', description: m.description ?? '', category: CATEGORIES.includes(category) ? category : 'PRODUCTIVITY' },
-        tools: toolsOut,
-        ...(pos.length
-            ? {
-                test_cases: pos.map((p) => ({ description: p.scenario, user_prompt: p.prompt, file_attachment_urls: null, tools_triggered: p.tools.join(', '), expected_output: p.expected, expected_output_url: null })),
-            }
-            : {}),
-        ...(neg.length
-            ? {
-                negative_test_cases: neg.map((n) => ({ description: n.scenario, user_prompt: n.prompt, file_attachment_urls: null, tools_triggered: null, expected_output: `${m.title} should not be invoked.`, expected_output_url: null })),
-            }
-            : {}),
+    // Icons, bundled into the package.
+    const assets = [];
+    const icon = async (url, file, label) => {
+        if (!url)
+            return undefined;
+        const got = await fetchIcon(url, label, problems);
+        if (!got)
+            return undefined;
+        const path = `assets/${file}.${got.ext}`;
+        assets.push({ path, data: got.data });
+        return `./${path}`;
+    };
+    need(m.icon, 'icon is missing: a direct URL to a square image, 48 to 4096 px');
+    const logo = await icon(m.icon, 'logo', 'icon');
+    const composerIcon = (await icon(g.composerIcon, 'composer-icon', 'chatgpt.composerIcon')) ?? logo;
+    const logoDark = await icon(g.logoDark, 'logo-dark', 'chatgpt.logoDark');
+    const plugin = {
+        $schema: 'https://agent-plugins.org/schemas/1.0.0/plugin.schema.json',
+        name: m.name,
+        version: m.version ?? '1.0.0',
+        description: m.oneLiner ?? m.subtitle ?? m.title,
+        author: { name: developerName ?? m.title, ...(m.author?.url ? { url: m.author.url } : {}) },
+        ...(m.links?.website ? { homepage: m.links.website } : {}),
+        ...(m.repository ? { repository: m.repository } : {}),
+        extensions: {
+            'com.openai': {
+                interface: {
+                    displayName: m.title,
+                    shortDescription: m.subtitle ?? '',
+                    longDescription: m.description ?? '',
+                    developerName: developerName ?? '',
+                    category: cat ?? 'Other',
+                    capabilities: g.capabilities ?? [],
+                    websiteURL: m.links?.website,
+                    supportURL: m.links?.support,
+                    privacyPolicyURL: m.links?.privacy,
+                    termsOfServiceURL: m.links?.terms,
+                    ...(prompts.length ? { defaultPrompt: prompts.slice(0, 3) } : {}),
+                    ...(g.brandColor ? { brandColor: g.brandColor } : {}),
+                    ...(g.brandColorDark ? { brandColorDark: g.brandColorDark } : {}),
+                    ...(logo ? { logo } : {}),
+                    ...(composerIcon ? { composerIcon } : {}),
+                    ...(logoDark ? { logoDark } : {}),
+                },
+                review: {
+                    test_cases: {
+                        positive: pos.map((p) => ({ description: p.scenario, prompt: p.prompt, tools_triggered: p.tools.join(', '), expected_behavior: p.expected })),
+                        negative: neg.map((n) => ({ description: n.scenario, prompt: n.prompt })),
+                    },
+                    ...(g.demoVideo ? { demo_recording_url: g.demoVideo } : {}),
+                    ...(g.commerce !== undefined ? { commerce: g.commerce } : {}),
+                    ...(g.commerceDescription ? { commerce_description: g.commerceDescription } : {}),
+                },
+                publication: {
+                    ...(g.countries ? { countries: g.countries } : {}),
+                    ...(g.releaseNotes ? { release_notes: g.releaseNotes } : {}),
+                    ...(g.translations ? { translations: g.translations } : {}),
+                },
+            },
+        },
     };
-    const steps = `# ChatGPT submission: ${m.title}
+    const mcp = { $schema: 'https://agent-plugins.org/schemas/1.0.0/mcp.schema.json', mcpServers: { [m.name]: { type: 'streamable-http', url: m.server.url } } };
+    const pkg = zip([
+        { path: 'plugin.json', data: JSON.stringify(plugin, null, 2) + '\n' },
+        { path: 'mcp.json', data: JSON.stringify(mcp, null, 2) + '\n' },
+        ...assets,
+    ]);
+    const zipName = `${m.name}-${m.version ?? '1.0.0'}.zip`;
+    // Justifications still go in the dashboard, one per hint, per tool.
+    const justified = tools
+        .map((t) => {
+        const j = justify(t, m.title, m.justifications?.[t.name]);
+        const a = t.annotations ?? {};
+        return `### ${t.name}\n- readOnlyHint ${!!a.readOnlyHint}: ${j.read_only_justification}\n- openWorldHint ${!!a.openWorldHint}: ${j.open_world_justification}\n- destructiveHint ${!!a.destructiveHint}: ${j.destructive_justification}`;
+    })
+        .join('\n\n');
+    const drafted = tools.filter((t) => !m.justifications?.[t.name]).map((t) => t.name);
+    if (drafted.length)
+        todo.push(`Read the drafted justifications for ${drafted.join(', ')} in chatgpt.md. Once they say exactly what each tool changes, save them under "justifications" in mcplane.json.`);
+    const steps = `# ChatGPT submission: ${m.title} ${m.version ?? ''}
 
-Upload \`chatgpt-app-submission.json\` on the Info step ("Use Codex to fill this form"): it fills app info, tool justifications and tests.
+## 1. Upload the package
+platform.openai.com/plugins → **Upload new or existing plugin** → choose your verified developer identity → upload \`${zipName}\`.
+It fills the listing, icons, test cases, demo video, release notes and translations. To change any of them later, edit mcplane.json, bump "version" and run \`mcplane pack chatgpt\` again.
 
-## Before you start
-- A verified organisation on platform.openai.com (Settings, Organization). Start early; it can lag.
-- Domain challenge: the MCP step gives you a token to serve as plain text at ${new URL(m.server.url).origin}/.well-known/openai-apps-challenge.
-- A demo video recorded in ChatGPT developer mode showing the tools your tests use, hosted as an .mp4 URL.
-- Icons: a directory icon (square PNG, 256 px or more) and a composer icon (48 px or more; the developer-mode dialog caps uploads at 10 KB).
+## 2. Resolve findings
+Open **Metadata & Skills** and **MCPs**, wait for the checks, fix anything listed (Copy issues is handy), and upload again if the package changes.
+Domain verification: serve the token it gives you as plain text at ${new URL(m.server.url).origin}/.well-known/openai-apps-challenge, and keep it there.
 
-## Fields the JSON doesn't cover
-- Developer identity and Plugin Author: must match your verified legal or business name.
-- Website: ${m.links?.website ?? 'MISSING'}
-- Customer support URL (a URL, not an email): ${m.links?.support ?? 'MISSING'}
-- Privacy policy: ${m.links?.privacy ?? 'MISSING'}
-- Terms: ${m.links?.terms ?? 'MISSING'}
-- MCP server URL: ${m.server.url} (${m.server.auth === 'oauth' ? 'OAuth' : 'No Auth'})${m.server.auth === 'oauth' ? `\n- Test credentials: ${m.reviewerAccess ?? 'MISSING: an email-and-password demo account with no 2FA, seeded for every test case'}` : ''}
-- Prompts (up to 3): ${(m.prompts ?? []).slice(0, 3).map((p) => `"${p}"`).join(', ') || 'none set'}
+## 3. What only you can enter
+- **Review details:** reviewer credentials${m.server.auth === 'oauth' ? ` (${m.reviewerAccess ?? 'an email-and-password account with no 2FA, SMS or email confirmation, seeded for every test case'})` : ' (none needed: no sign-in)'}. Credentials never go in the ZIP.
+- **Hint justifications**, one per value on every tool (200 characters each, cut without warning):
+
+${justified}
+
+- **Submit for review** and the policy attestations.
 
 ## Traps
-- Run "Scan Tools" twice if the first click shows nothing.
-- Justifications over 200 characters are cut without warning.
-- Typing into fields while the draft autosaves can drop characters; re-read before submitting.
-- "Submit for Review" shows nothing for about 20 seconds. Confirm on the plugins list that the version reads "Review".
-- One version can be in review at a time. Changing tools on a published plugin needs a new version.
+- One review can be active per plugin. To replace a package in review, cancel the review first.
+- "Submit for review" can show nothing for a while; confirm the status on the Plugins page.
+- Tool changes don't need a new package: OpenAI's scans pick them up. Listing changes do.
 
-When it's in: \`mcplane submitted chatgpt --app-id <asdk_app_… from the URL>\`
+When it's in: \`mcplane submitted chatgpt --version ${m.version ?? '1.0.0'} --app-id <asdk_app_… from the URL>\`
 `;
     return {
         files: [
-            { path: 'chatgpt-app-submission.json', content: JSON.stringify(json, null, 2) + '\n' },
-            { path: 'chatgpt.md', content: steps },
+            { path: `chatgpt/${zipName}`, content: pkg },
+            { path: 'chatgpt/plugin.json', content: JSON.stringify(plugin, null, 2) + '\n' },
+            { path: 'chatgpt/chatgpt.md', content: steps },
         ],
         problems,
         todo,
@@ -152,6 +284,7 @@ function readWrite(tools) {
     return writes.length === tools.length ? 'Write only (check: most servers also read)' : 'Read and write';
 }
 export async function claudePack(m, token) {
+    m = forStore(m, 'claude-connectors');
     const tools = await listTools(m, token);
     const problems = [];
     if ((m.oneLiner ?? '').length > 200)
@@ -217,6 +350,7 @@ When it's in: \`mcplane submitted claude-connectors\`
     return { files: [{ path: 'claude-connectors.md', content: md }], problems, todo: [] };
 }
 export async function simplePack(m, store) {
+    m = forStore(m, store);
     const problems = [];
     let md = '';
     if (store === 'cursor') {
@@ -272,9 +406,10 @@ export async function writePack(pack, dir = process.cwd()) {
     await mkdir(out, { recursive: true });
     const written = [];
     for (const f of pack.files) {
+        await mkdir(dirname(resolve(out, f.path)), { recursive: true });
         await writeFile(resolve(out, f.path), f.content);
         written.push(`.mcplane/packs/${f.path}`);
     }
     return written;
 }
-export const _test = { thirdPerson, justify };
+export const _test = { thirdPerson, justify, contrast, category };

package/dist/publish.js

@@ -233,15 +233,24 @@ function prepared(m, store) {
         return { store, done: false, lines: [`smithery mcp publish ${m.server.url} -n @<your-org>/${m.name}`, 'Or at https://smithery.ai/new. If Smithery’s scan can’t get past your sign-in, serve /.well-known/mcp/server-card.json describing your tools.'] };
     }
     if (store === 'glama') {
+        const reg = registryName(m);
         const owner = gh?.owner ?? '<your-github-user>';
+        const domainNs = !reg.startsWith('io.github.');
+        const domain = reg.split('/')[0].split('.').reverse().join('.');
         return {
             store,
             done: false,
             lines: [
-                `Hosted servers: Glama imports a connector from the official registry at https://glama.ai/mcp/connectors/${registryName(m)}. Publish there first, then claim it.`,
-                `Code on GitHub: add ${gh ? `https://github.com/${gh.owner}/${gh.repo}` : 'the repo'} at https://glama.ai/mcp/servers ("Add MCP Server"); Glama checks license, security and health, and scores it.`,
-                'To claim either, commit glama.json at the repo root:',
-                JSON.stringify({ $schema: 'https://glama.ai/mcp/schemas/server.json', maintainers: [owner] }, null, 2),
+                `Hosted server: Glama imports it from the official registry as a connector, https://glama.ai/mcp/connectors/${reg}. Publish there first.`,
+                domainNs
+                    ? `To claim it: open that page, choose Claim ownership, sign in, and verify ${domain} with the token Glama shows, either as a TXT record at _glama-claim.${domain} or as https://${domain}/.well-known/glama.json ({"$schema":"https://glama.ai/mcp/schemas/connector.json","claim":"glama_claim_…"}). One verification covers every connector under the domain.`
+                    : `To claim it: open that page, choose Claim ownership and "Claim with GitHub" as ${reg.split('/')[0].slice('io.github.'.length)}. An organisation also needs the Glama GitHub App installed.`,
+                ...(gh
+                    ? [
+                        `Server code on GitHub is a separate listing: add https://github.com/${gh.owner}/${gh.repo} at https://glama.ai/mcp/servers ("Add MCP Server") and claim it with glama.json at the repo root:`,
+                        JSON.stringify({ $schema: 'https://glama.ai/mcp/schemas/server.json', maintainers: [owner] }, null, 2),
+                    ]
+                    : []),
                 'Both awesome lists require the Glama badge on each entry, so do this first.',
             ],
         };

package/dist/types.d.ts

@@ -39,6 +39,8 @@ export interface Manifest {
     icon?: string;
     prompts?: string[];
     stores?: StoreId[];
+    /** Per-store listing text, like fastlane's per-language metadata. Each store falls back to the top-level fields. */
+    listing?: Partial<Record<StoreId, ListingText>>;
     /** Review test cases: ChatGPT wants exactly 5 positive and 3 negative. */
     tests?: {
         positive?: {
@@ -66,6 +68,31 @@ export interface Manifest {
         description?: string;
         file?: string;
     };
+    /** ChatGPT plugin package fields (plugin.json) that have no shared equivalent. */
+    chatgpt?: {
+        /** Publisher name shown in the listing (80 max). Defaults to author.name. */
+        developerName?: string;
+        /** Capability labels (20 max, 120 characters each). */
+        capabilities?: string[];
+        /** #RRGGBB with 2:1 contrast against white; the dark one against #212121. */
+        brandColor?: string;
+        brandColorDark?: string;
+        /** Direct image URLs; default to "icon". */
+        composerIcon?: string;
+        logoDark?: string;
+        /** Reviewer-accessible video URL showing the main use cases (required for review). */
+        demoVideo?: string;
+        commerce?: boolean;
+        commerceDescription?: string;
+        /** Uppercase country codes; leave out to keep current targeting. */
+        countries?: string[];
+        /** What changed in this version (required for review). */
+        releaseNotes?: string;
+        translations?: Record<string, {
+            subtitle?: string;
+            description?: string;
+        }>;
+    };
     /** Grok marketplace entry overrides. */
     grok?: {
         description?: string;
@@ -78,6 +105,13 @@ export interface Manifest {
     /** How reviewers get in, for servers behind sign-in. Never put the password here; say where it lives. */
     reviewerAccess?: string;
 }
+export interface ListingText {
+    title?: string;
+    subtitle?: string;
+    oneLiner?: string;
+    description?: string;
+    prompts?: string[];
+}
 export interface Tool {
     name: string;
     title?: string;
@@ -87,6 +121,7 @@ export interface Tool {
         required?: string[];
     };
     outputSchema?: unknown;
+    _meta?: Record<string, unknown>;
     annotations?: {
         title?: string;
         readOnlyHint?: boolean;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.3.1";
+export declare const VERSION = "0.4.1";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.3.1';
+export const VERSION = '0.4.1';

package/dist/zip.d.ts

@@ -0,0 +1,4 @@
+export declare function zip(files: {
+    path: string;
+    data: Uint8Array | string;
+}[]): Uint8Array;

package/dist/zip.js

@@ -0,0 +1,75 @@
+/**
+ * A minimal ZIP writer (deflate, no dependencies): enough to build the plugin
+ * package ChatGPT's submission portal takes.
+ */
+import { deflateRawSync } from 'node:zlib';
+const CRC = (() => {
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[n] = c >>> 0;
+    }
+    return t;
+})();
+function crc32(buf) {
+    let c = 0xffffffff;
+    for (const b of buf)
+        c = CRC[(c ^ b) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+export function zip(files) {
+    const enc = new TextEncoder();
+    const locals = [];
+    const central = [];
+    let offset = 0;
+    for (const f of files) {
+        const name = enc.encode(f.path);
+        const raw = typeof f.data === 'string' ? enc.encode(f.data) : f.data;
+        const body = deflateRawSync(raw);
+        const crc = crc32(raw);
+        const local = new Uint8Array(30 + name.length);
+        const lv = new DataView(local.buffer);
+        lv.setUint32(0, 0x04034b50, true);
+        lv.setUint16(4, 20, true);
+        lv.setUint16(6, 0x0800, true); // UTF-8 names
+        lv.setUint16(8, 8, true); // deflate
+        lv.setUint32(14, crc, true);
+        lv.setUint32(18, body.length, true);
+        lv.setUint32(22, raw.length, true);
+        lv.setUint16(26, name.length, true);
+        local.set(name, 30);
+        const cen = new Uint8Array(46 + name.length);
+        const cv = new DataView(cen.buffer);
+        cv.setUint32(0, 0x02014b50, true);
+        cv.setUint16(4, 20, true);
+        cv.setUint16(6, 20, true);
+        cv.setUint16(8, 0x0800, true);
+        cv.setUint16(10, 8, true);
+        cv.setUint32(16, crc, true);
+        cv.setUint32(20, body.length, true);
+        cv.setUint32(24, raw.length, true);
+        cv.setUint16(28, name.length, true);
+        cv.setUint32(42, offset, true);
+        cen.set(name, 46);
+        locals.push(local, body);
+        central.push(cen);
+        offset += local.length + body.length;
+    }
+    const cenSize = central.reduce((n, c) => n + c.length, 0);
+    const end = new Uint8Array(22);
+    const ev = new DataView(end.buffer);
+    ev.setUint32(0, 0x06054b50, true);
+    ev.setUint16(8, files.length, true);
+    ev.setUint16(10, files.length, true);
+    ev.setUint32(12, cenSize, true);
+    ev.setUint32(16, offset, true);
+    const out = new Uint8Array(offset + cenSize + 22);
+    let p = 0;
+    for (const part of [...locals, ...central, end]) {
+        out.set(part, p);
+        p += part.length;
+    }
+    return out;
+}

package/package.json

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

package/schema.json

@@ -62,7 +62,7 @@
     },
     "category": {
       "type": "string",
-      "description": "ChatGPT category, e.g. DEVELOPER_TOOLS, PRODUCTIVITY, BUSINESS."
+      "description": "ChatGPT category: Productivity, Creativity, Developer Tools, Business & Operations, Data & Analytics, Communication, Education & Research, Security, Finance, Healthcare, Travel, Entertainment or Other (the old form's names like DEVELOPER_TOOLS are mapped)."
     },
     "server": {
       "type": "object",
@@ -279,6 +279,111 @@
     "reviewerAccess": {
       "type": "string",
       "description": "How reviewers get in, for servers behind sign-in. Say where credentials live; never put a password here."
+    },
+    "listing": {
+      "type": "object",
+      "description": "Per-store listing text, like fastlane's per-language metadata. Each store falls back to the top-level title, subtitle, oneLiner, description and prompts.",
+      "propertyNames": {
+        "$ref": "#/$defs/store"
+      },
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "title": {
+            "type": "string"
+          },
+          "subtitle": {
+            "type": "string"
+          },
+          "oneLiner": {
+            "type": "string"
+          },
+          "description": {
+            "type": "string"
+          },
+          "prompts": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        }
+      }
+    },
+    "chatgpt": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "ChatGPT plugin package fields (plugin.json) with no shared equivalent.",
+      "properties": {
+        "developerName": {
+          "type": "string",
+          "description": "Publisher name (80 max). Defaults to author.name.",
+          "maxLength": 80
+        },
+        "capabilities": {
+          "type": "array",
+          "maxItems": 20,
+          "items": {
+            "type": "string",
+            "maxLength": 120
+          }
+        },
+        "brandColor": {
+          "type": "string",
+          "description": "#RRGGBB with 2:1 contrast against white.",
+          "pattern": "^#[0-9a-fA-F]{6}$"
+        },
+        "brandColorDark": {
+          "type": "string",
+          "description": "#RRGGBB with 2:1 contrast against #212121.",
+          "pattern": "^#[0-9a-fA-F]{6}$"
+        },
+        "composerIcon": {
+          "$ref": "#/$defs/url"
+        },
+        "logoDark": {
+          "$ref": "#/$defs/url"
+        },
+        "demoVideo": {
+          "$ref": "#/$defs/url",
+          "description": "Reviewer-accessible video URL showing the main use cases. Required for review."
+        },
+        "commerce": {
+          "type": "boolean"
+        },
+        "commerceDescription": {
+          "type": "string"
+        },
+        "countries": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "pattern": "^[A-Z]{2}$"
+          }
+        },
+        "releaseNotes": {
+          "type": "string",
+          "description": "What changed in this version. Required for review."
+        },
+        "translations": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "subtitle": {
+                "type": "string",
+                "maxLength": 30
+              },
+              "description": {
+                "type": "string",
+                "maxLength": 4000
+              }
+            }
+          }
+        }
+      }
     }
   }
 }