@pitcher/cli-scripts 2.9.0 → 2.11.0

package/README.md

@@ -45,6 +45,18 @@ One config entry = one org, because the API key is org-specific. To work against
 - Read commands are marked `readOnlyHint`. `dev-sync` counts as a write (it mutates remote dev-override state).
 - `publish-app` is always marked `destructiveHint` (it creates a live, org-visible release). Other write tools get `destructiveHint` only when the resolved environment is production (`NG_ENV=prod`, or `NG_ORG` other than `dev` with `NG_ENV` unset). This steers hosts toward requiring extra confirmation before mutating a production org.
 
+### Desktop Extension (`.mcpb`)
+
+For one-click install in Claude Desktop (name + icon, an install-time API-key/org form, no hand-edited config, no Node prerequisite), build a `.mcpb` bundle:
+
+```bash
+yarn mcpb:pack        # → pitcher.mcpb (validated + packed)
+```
+
+Install by double-clicking `pitcher.mcpb` (or Settings → Extensions → Install Extension). Claude Desktop prompts for the API key (stored in the OS keychain) and organization; both are editable afterward, so switching orgs needs no reinstall.
+
+The bundle reuses the same server as `p mcp` but registers a **content-tool subset (47)** — it omits the developer-only `publish-app` and `dev-sync`/`dev-sync-revert`. The `organization` field accepts a subdomain (`acme`), a bare hostname (`acme.my.pitcher.com`), or a full `https://` URL. Build details (esbuild single-file, version injection) live in `mcpb/` and `CLAUDE.md`.
+
 This section is a reference only. For app-development conventions (modules, settings, mount points, SFDC), see the `pitcher-apps` skill, not this README.
 
 ## To run the `publish-app` command:
@@ -244,6 +256,9 @@ Create/list/get HTML email templates for the emails app. `create`, `list`, and `
 # Create a template from an HTML file (inline CSS)
 p email-template create --instance-id 01... --name "Welcome" --body-file ./welcome.html --api-key myapikey
 
+# ...or pass the HTML inline instead of a file (use one, not both)
+p email-template create --instance-id 01... --name "Welcome" --body-html "<p>Hi {{recipient.firstName}}</p>" --api-key myapikey
+
 # List templates (optionally filter by name/status/category/target)
 p email-template list --instance-id 01... --api-key myapikey
 
@@ -266,6 +281,9 @@ Create/list DSR (Digital Sales Room) landing-page templates, and set one as the
 # Create a landing template from an HTML file (must contain the email-gate marker)
 p dsr-landing create --instance-id 01... --name "Default" --html-file ./landing.html --api-key myapikey
 
+# ...or pass the HTML (and optionally CSS) inline instead of a file (use one, not both)
+p dsr-landing create --instance-id 01... --name "Default" --html "<div data-pitcher-email-gate></div>" --api-key myapikey
+
 # Create and set as default in one call
 p dsr-landing create --instance-id 01... --name "Default" --html-file ./landing.html --default --api-key myapikey
 
@@ -279,7 +297,7 @@ p dsr-landing list --instance-id 01... --api-key myapikey
 p dsr-landing scaffold --out ./landing.html --api-key myapikey
 ```
 
-`--html-file` must contain the `data-pitcher-email-gate` marker verbatim (the platform injects the email-gate form there) — `create` fails client-side before any request if it's missing.
+The landing HTML (whether via `--html-file` or `--html`) must contain the `data-pitcher-email-gate` marker verbatim (the platform injects the email-gate form there) — `create` fails client-side before any request if it's missing. Provide exactly one of `--html` / `--html-file` (and at most one of `--css` / `--css-file`).
 
 Run `p dsr-landing create --help` for the full token/marker reference (editable-region attributes, recipient/customer/org/rep tokens).
 

package/dist/src/commands/canvases.js

@@ -13,14 +13,17 @@ export async function runCanvasesList(opts, deps = {}) {
         assertIntFlags(opts);
         const client = clientFor(opts, deps);
         const params = { instance_id: opts.instanceId, ...listPageParams(opts) };
-        // Send each type flag ONLY when set. The server FilterSet does
-        // setdefault("is_block", False), so blocks are hidden unless --is-block.
-        if (opts.isTemplate)
-            params.is_template = true;
-        if (opts.isSection)
-            params.is_section = true;
-        if (opts.isBlock)
-            params.is_block = true;
+        // Forward each type flag only when explicitly set (true OR false) — the server honors
+        // is_section=false / is_template=false for precise type filtering. CLI switches are
+        // present→true / absent→undefined, so this is behavior-preserving for the CLI; it lets a
+        // programmatic caller (the MCP `type` filter) isolate one canvas type. The server FilterSet
+        // does setdefault("is_block", False), so blocks stay hidden unless is_block is set.
+        if (opts.isTemplate !== undefined)
+            params.is_template = opts.isTemplate;
+        if (opts.isSection !== undefined)
+            params.is_section = opts.isSection;
+        if (opts.isBlock !== undefined)
+            params.is_block = opts.isBlock;
         if (opts.tags)
             params.tags__in = opts.tags;
         if (opts.idIn)

package/dist/src/commands/dsrLanding.d.ts

@@ -8,7 +8,9 @@ export interface DsrLandingDeps {
 export declare function runDsrLandingCreate(opts: CommonOpts & {
     instanceId?: string;
     name?: string;
+    html?: string;
     htmlFile?: string;
+    css?: string;
     cssFile?: string;
     mergeSchema?: string;
     thumbnailUrl?: string;

package/dist/src/commands/dsrLanding.js

@@ -3,7 +3,7 @@ import { clientFor, toCliError } from '../core/http.js';
 import { ok, fail } from '../core/envelope.js';
 import { createCliError } from '../core/errors.js';
 import { emitEnvelope } from '../core/output.js';
-import { readTextFile } from '../core/readInput.js';
+import { resolveTextInput } from '../core/readInput.js';
 import { parseJsonArray } from '../schema/content.js';
 import { withAuthFlags } from './withAuth.js';
 import { withInstanceFlag } from './withInstance.js';
@@ -12,7 +12,7 @@ const DSR_ENDPOINT = '/core/api/protected/dsr-landing-templates';
 const REQUIRED_MARKER = 'data-pitcher-email-gate';
 const TOKEN_HELP = `
 Required marker (the platform injects the email-gate form here at render time):
-  data-pitcher-email-gate    must be present verbatim in --html-file, or create fails client-side
+  data-pitcher-email-gate    must be present verbatim in the landing HTML (--html or --html-file), or create fails client-side
 
 Editable regions (optional, edited in the DSR landing editor without touching markup):
   data-field-id="..."            unique id for the editable block
@@ -33,10 +33,15 @@ export async function runDsrLandingCreate(opts, deps = {}) {
             throw createCliError('VALIDATION', '--name is required for dsr-landing create');
         if (!opts.instanceId)
             throw createCliError('VALIDATION', '--instance-id is required for dsr-landing create');
-        if (!opts.htmlFile)
-            throw createCliError('VALIDATION', '--html-file is required for dsr-landing create');
-        // readTextFile throws VALIDATION on a missing/unreadable file, before any request is made.
-        const html = readTextFile(opts.htmlFile);
+        // Inline HTML (html) OR a file path (htmlFile), not both — exactly one is required.
+        // Inline is the only route that works in hosts without a shared filesystem (e.g. Claude
+        // Desktop). resolveTextInput throws VALIDATION on conflict/oversize/unreadable.
+        const html = resolveTextInput(opts.html, opts.htmlFile, 'html');
+        if (html === undefined) {
+            // host-neutral wording: the MCP tool params are html/htmlFile, the CLI flags are --html/--html-file
+            throw createCliError('VALIDATION', 'provide the landing HTML inline or as a file (html / htmlFile) for dsr-landing create');
+        }
+        // Marker check runs on the resolved HTML regardless of source.
         if (!html.includes(REQUIRED_MARKER)) {
             throw createCliError('VALIDATION', `landing HTML must contain the ${REQUIRED_MARKER} marker`);
         }
@@ -44,8 +49,9 @@ export async function runDsrLandingCreate(opts, deps = {}) {
             throw createCliError('VALIDATION', '--language must be at most 10 characters');
         }
         const body = { instance_id: opts.instanceId, name: opts.name, html };
-        if (opts.cssFile)
-            body.css = readTextFile(opts.cssFile);
+        const css = resolveTextInput(opts.css, opts.cssFile, 'css');
+        if (css !== undefined)
+            body.css = css;
         if (opts.mergeSchema)
             body.merge_schema = parseJsonArray(opts.mergeSchema, 'merge-schema');
         if (opts.thumbnailUrl)
@@ -117,8 +123,10 @@ export function createDsrLandingCommand() {
     const cmd = new Command('dsr-landing').description('create/list DSR (Digital Sales Room) landing-page templates, and set one as default');
     withInstanceFlag(withAuthFlags(cmd.command('create')))
         .option('--name <name>', 'Template name (required)')
-        .option('--html-file <path>', `Path to the landing HTML (required; must contain ${REQUIRED_MARKER})`)
-        .option('--css-file <path>', 'Path to a CSS file for the template')
+        .option('--html <html>', `Inline landing HTML (must contain ${REQUIRED_MARKER}). Use this OR --html-file`)
+        .option('--html-file <path>', `Path to the landing HTML (must contain ${REQUIRED_MARKER}). Use this OR --html`)
+        .option('--css <css>', 'Inline CSS for the template. Use this OR --css-file')
+        .option('--css-file <path>', 'Path to a CSS file for the template. Use this OR --css')
         .option('--merge-schema <json>', 'Merge schema array as inline JSON')
         .option('--language <lang>', 'Language code (max 10 chars)')
         .option('--thumbnail-url <url>', 'Thumbnail image URL')

package/dist/src/commands/emailTemplate.d.ts

@@ -8,6 +8,7 @@ export interface EmailTemplateDeps {
 export declare function runEmailTemplateCreate(opts: CommonOpts & {
     instanceId?: string;
     name?: string;
+    bodyHtml?: string;
     bodyFile?: string;
     subject?: string;
     tags?: string;

package/dist/src/commands/emailTemplate.js

@@ -3,7 +3,7 @@ import { clientFor, toCliError } from '../core/http.js';
 import { ok, fail } from '../core/envelope.js';
 import { createCliError } from '../core/errors.js';
 import { emitEnvelope } from '../core/output.js';
-import { readTextFile } from '../core/readInput.js';
+import { resolveTextInput } from '../core/readInput.js';
 import { listLimitOffsetParams } from '../core/pagination.js';
 import { assertIntFlags, parseJsonObject } from '../schema/content.js';
 import { withAuthFlags } from './withAuth.js';
@@ -26,9 +26,12 @@ export async function runEmailTemplateCreate(opts, deps = {}) {
         const body = { name: opts.name };
         if (opts.subject)
             body.subject = opts.subject;
-        // readTextFile throws VALIDATION on a missing/unreadable file, before any request is made.
-        if (opts.bodyFile)
-            body.body = readTextFile(opts.bodyFile);
+        // Inline body (bodyHtml) OR a file path (bodyFile), not both. Inline is the only
+        // route that works in hosts without a shared filesystem (e.g. Claude Desktop).
+        // resolveTextInput throws VALIDATION on conflict/oversize/unreadable, before any request.
+        const bodyHtml = resolveTextInput(opts.bodyHtml, opts.bodyFile, 'body');
+        if (bodyHtml !== undefined)
+            body.body = bodyHtml;
         if (opts.tags)
             body.tags = parseJsonObject(opts.tags, 'tags');
         if (opts.metadata)
@@ -86,6 +89,7 @@ export function createEmailTemplateCommand() {
     const cmd = new Command('email-template').description('create/list/get HTML email templates for the emails app');
     withInstanceFlag(withAuthFlags(cmd.command('create')))
         .option('--name <name>', 'Template name (required)')
+        .option('--body-html <html>', 'Inline HTML body (inline CSS). Use this OR --body-file')
         .option('--body-file <path>', 'Path to an HTML file (inline CSS) used as the template body')
         .option('--subject <text>', 'Email subject (supports {{tokens}})')
         .option('--tags <json>', 'Tags object as inline JSON')

package/dist/src/core/readInput.d.ts

@@ -1,2 +1,4 @@
 export declare function readTextFile(filePath: string): string;
 export declare function readJsonFile(filePath: string): unknown;
+export declare const MAX_INLINE_BYTES = 400000;
+export declare function resolveTextInput(inline: string | undefined, file: string | undefined, label: string): string | undefined;

package/dist/src/core/readInput.js

@@ -21,3 +21,27 @@ export function readJsonFile(filePath) {
         throw createCliError('VALIDATION', `invalid JSON in ${filePath}`);
     }
 }
+// Cap inbound inline content so a runaway model-generated payload fails cleanly
+// client-side (a clear VALIDATION) instead of ballooning memory or POSTing a huge body
+// that the platform rejects with an opaque 4xx. Bytes, not chars (UTF-8).
+export const MAX_INLINE_BYTES = 400000;
+// Resolve a text field from either an inline string or a file path (exactly one).
+// Truthy guards (not `!== undefined`) preserve the pre-existing falsy-skip behavior:
+// an empty inline string or empty path counts as "not provided", matching the old
+// `if (opts.bodyFile)` / `if (opts.htmlFile)` checks. Returns undefined if neither.
+// The size cap applies only to inline content — a file path is disk-bounded already,
+// and capping it could break existing large-file callers.
+export function resolveTextInput(inline, file, label) {
+    if (inline && file) {
+        throw createCliError('VALIDATION', `provide either an inline ${label} or a ${label} file, not both`);
+    }
+    if (inline) {
+        if (Buffer.byteLength(inline, 'utf-8') > MAX_INLINE_BYTES) {
+            throw createCliError('VALIDATION', `inline ${label} exceeds ${MAX_INLINE_BYTES} bytes`);
+        }
+        return inline;
+    }
+    if (file)
+        return readTextFile(file);
+    return undefined;
+}

package/dist/src/mcp/bundled.d.ts

@@ -0,0 +1,4 @@
+import type { ToolDescriptor } from './tools/types.js';
+export declare const BUNDLE_EXCLUDED_TOOLS: Set<string>;
+export declare const bundledTools: ToolDescriptor[];
+export declare function normalizeOrgUrl(env: NodeJS.ProcessEnv): void;

package/dist/src/mcp/bundled.js

@@ -0,0 +1,25 @@
+import { allTools } from './registry.js';
+// Developer-only tools excluded from the consumer .mcpb bundle. `publish_app` is alwaysDestructive
+// (creates a live, org-visible app release); `dev_sync`/`dev_sync_revert` mutate remote S3 dev state.
+// None are relevant to a non-technical adopter installing the extension. The CLI `p mcp` keeps all 50.
+export const BUNDLE_EXCLUDED_TOOLS = new Set(['pitcher_publish_app', 'pitcher_dev_sync', 'pitcher_dev_sync_revert']);
+// The tool set the .mcpb bundle registers.
+export const bundledTools = allTools.filter((t) => !BUNDLE_EXCLUDED_TOOLS.has(t.name));
+// resolveBaseUrl interpolates NG_ORG into `https://<org>.my.pitcher.com`, so anything that is
+// already a host (a full URL, or a bare hostname like "acme.my.pitcher.com") must route via NG_URL
+// instead — otherwise it becomes a double-interpolated garbage host. The .mcpb install form accepts
+// a subdomain, hostname, or full URL in one `org` field; this moves host-shaped values to NG_URL
+// before the server reads env. A plain subdomain (no dot) stays in NG_ORG. Mutates env in place.
+export function normalizeOrgUrl(env) {
+    const org = env.NG_ORG?.trim();
+    if (!org)
+        return;
+    if (/^https?:\/\//i.test(org)) {
+        env.NG_URL = org;
+        delete env.NG_ORG;
+    }
+    else if (org.includes('.')) {
+        env.NG_URL = `https://${org}`;
+        delete env.NG_ORG;
+    }
+}

package/dist/src/mcp/prompts/announcements.d.ts

@@ -0,0 +1,2 @@
+import type { PromptDescriptor } from './types.js';
+export declare const announcementsPrompts: PromptDescriptor[];

package/dist/src/mcp/prompts/announcements.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { instanceLine, recipePreamble } from './shared.js';
+export const announcementsPrompts = [
+    {
+        name: 'seed_announcement',
+        title: 'Create announcement',
+        description: 'Author an on-brand in-app announcement (title + body HTML + CTA) and create it in an instance.',
+        argsSchema: {
+            instance_id: z.string().optional().describe('Target instance ID (leave blank to resolve interactively)'),
+            vertical: z.string().optional().describe('pharma | medtech | cpg | finserv | generic'),
+            use_case: z.string().optional().describe('Short description of what this announcement is about'),
+        },
+        build: (args) => {
+            const vertical = args.vertical || 'generic';
+            const useCase = args.use_case || 'a general product / process announcement a rep would see in-app';
+            const text = [
+                recipePreamble(),
+                '',
+                '## Task: seed an announcement',
+                instanceLine(args.instance_id),
+                `Vertical: ${vertical}. Use case: ${useCase}.`,
+                '',
+                'Steps:',
+                '1. Draft a short, on-brand announcement: a concise title and a **body in inline-CSS HTML** ' +
+                    'following the principles above — a few sentences, one clear call-to-action, brand-derived colors, ' +
+                    'and any dynamic values via escaped `{{token}}` merge fields.',
+                '2. Create it by calling `pitcher_announcements_create` with `{ instanceId, title, body }` — ' +
+                    'pass the HTML **inline via `body`** (a file path cannot cross a host\'s sandbox boundary, so always inline). ' +
+                    'Add `priority` only if the user asks for an important announcement.',
+                '3. Report the created announcement id and title.',
+            ].join('\n');
+            return [{ role: 'user', content: { type: 'text', text } }];
+        },
+    },
+];

package/dist/src/mcp/prompts/dsr.d.ts

@@ -0,0 +1,2 @@
+import type { PromptDescriptor } from './types.js';
+export declare const dsrPrompts: PromptDescriptor[];

package/dist/src/mcp/prompts/dsr.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { instanceLine, safetyPreamble } from './shared.js';
+export const dsrPrompts = [
+    {
+        name: 'seed_dsr',
+        title: 'Create and share a DSR',
+        description: 'Share a canvas (or files) as a Digital Sales Room with the right gating, optionally branded with a landing page.',
+        argsSchema: {
+            instance_id: z.string().optional().describe('Target instance ID (leave blank to resolve interactively)'),
+            canvas_id: z.string().optional().describe('Canvas to share (leave blank to pick one interactively)'),
+            audience: z.string().optional().describe('Who the DSR is for, e.g. "internal", "a known contact", "an account/domain"'),
+        },
+        build: (args) => {
+            const audience = args.audience || 'the intended external recipient';
+            const text = [
+                // NOTE: this is a share WORKFLOW recipe, not an HTML-authoring one — it does NOT author a
+                // landing page (that is the separate `seed_dsr_landing` recipe). It only BINDS an existing
+                // template. So it embeds only the safety guidance, not the HTML design principles.
+                safetyPreamble(),
+                '',
+                '## DSR sharing guidance',
+                '- **Source is exactly one of** a canvas (`canvasId`) OR files (`shareboxFileIds`).',
+                `- **Pick the gating (\`authStrategy\`) by audience.** For ${audience}: internal/quick demo → \`none\` ` +
+                    '(open link); a known individual → `specified_emails` (+ `allowedEmails`); a company → ' +
+                    '`specified_domains` (+ `allowedDomains`); the server default is `any_email`. Add `validUntil` ' +
+                    '(ISO datetime) to time-box a customer-facing link; set `allowForward`/`allowDownload` deliberately.',
+                '- **Branding the pre-auth page is a SEPARATE step:** this recipe only **binds** an existing ' +
+                    'landing template (`landingTemplateId`, discover via `pitcher_dsr_landing_list`; pass ' +
+                    '`landingContext` merge fields **as a JSON object serialized to a string**, not as an object). ' +
+                    'If no suitable template exists and the user wants a ' +
+                    'branded landing, author one FIRST with the **`seed_dsr_landing`** recipe, then bind its id here. ' +
+                    'Do NOT hand-write landing HTML in this recipe.',
+                '',
+                '## Task: create and share a DSR',
+                instanceLine(args.instance_id),
+                args.canvas_id ? `Canvas to share: ${args.canvas_id}.` : 'No canvas given — help the user pick one via `pitcher_canvases_list`.',
+                `Audience: ${audience}.`,
+                '',
+                'Steps:',
+                '1. Resolve the source (the given `canvas_id`, or pick a canvas with the user via `pitcher_canvases_list`).',
+                '2. Choose the gating strategy with the user per the guidance above; set expiry/forward/download as appropriate.',
+                '3. (Optional) To brand the pre-auth page, list templates with `pitcher_dsr_landing_list` and bind one via ' +
+                    '`landingTemplateId` — or point the user at `seed_dsr_landing` to author a new one first.',
+                '4. Call `pitcher_dsr_create` with the resolved fields. A denied/failed landing bind returns the link with a ' +
+                    'warning (not a failure) — surface it. Report the returned `short_url`.',
+            ].join('\n');
+            return [{ role: 'user', content: { type: 'text', text } }];
+        },
+    },
+];

package/dist/src/mcp/prompts/dsrLanding.d.ts

@@ -0,0 +1,2 @@
+import type { PromptDescriptor } from './types.js';
+export declare const dsrLandingPrompts: PromptDescriptor[];

package/dist/src/mcp/prompts/dsrLanding.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { instanceLine, recipePreamble } from './shared.js';
+export const dsrLandingPrompts = [
+    {
+        name: 'seed_dsr_landing',
+        title: 'Create DSR landing page',
+        description: 'Author a responsive DSR (Digital Sales Room) landing-page template and create it in an instance.',
+        argsSchema: {
+            instance_id: z.string().optional().describe('Target instance ID (leave blank to resolve interactively)'),
+            vertical: z.string().optional().describe('pharma | medtech | cpg | finserv | generic'),
+            set_default: z.string().optional().describe('"true" to also set it as the instance default'),
+        },
+        build: (args) => {
+            const vertical = args.vertical || 'generic';
+            const setDefault = args.set_default === 'true';
+            const text = [
+                recipePreamble(),
+                '',
+                '## Task: seed a DSR landing page',
+                instanceLine(args.instance_id),
+                `Vertical: ${vertical}.`,
+                '',
+                'Steps:',
+                '1. Draft a responsive landing HTML following the principles above. It **must contain the ' +
+                    '`data-pitcher-email-gate` marker** (the platform injects the email-gate form there). Use ' +
+                    '`clamp()` for fluid sizing (no media queries), guard `{{rep.*}}` merge fields with fallbacks, ' +
+                    'and pick an aesthetic that fits the vertical.',
+                '2. Create it by calling `pitcher_dsr_landing_create` with ' +
+                    `\`{ instanceId, name, html${setDefault ? ', default: true' : ''} }\` — pass the HTML **inline via ` +
+                    '`html`**, not a file path (inline is the only route that works in hosts without a shared filesystem).',
+                setDefault
+                    ? '   (`set_default` was "true" → pass `default: true` so it becomes the instance default.)'
+                    : '   (Leave `default` unset — the caller did not ask to set it as the instance default.)',
+                '3. The create endpoint is editor-gated; if it returns 403, surface it as-is. Report the created ' +
+                    'template id and, if applicable, the DSR link.',
+            ].join('\n');
+            return [{ role: 'user', content: { type: 'text', text } }];
+        },
+    },
+];

package/dist/src/mcp/prompts/emailTemplate.d.ts

@@ -0,0 +1,2 @@
+import type { PromptDescriptor } from './types.js';
+export declare const emailTemplatePrompts: PromptDescriptor[];

package/dist/src/mcp/prompts/emailTemplate.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { instanceLine, recipePreamble } from './shared.js';
+export const emailTemplatePrompts = [
+    {
+        name: 'seed_email_template',
+        title: 'Create email template',
+        description: 'Author an on-brand HTML email template for the emails app and create it in an instance.',
+        argsSchema: {
+            instance_id: z.string().optional().describe('Target instance ID (leave blank to resolve interactively)'),
+            vertical: z.string().optional().describe('pharma | medtech | cpg | finserv | generic'),
+            use_case: z.string().optional().describe('Short description of what this email is for'),
+        },
+        build: (args) => {
+            const vertical = args.vertical || 'generic';
+            const useCase = args.use_case || 'a general product-update email a rep would send to a customer';
+            const text = [
+                recipePreamble(),
+                '',
+                '## Task: seed an email template',
+                instanceLine(args.instance_id),
+                `Vertical: ${vertical}. Use case: ${useCase}.`,
+                '',
+                'Steps:',
+                '1. Draft compliant inline-CSS HTML following the principles above: max ~620px, table layout, ' +
+                    'one clear CTA, visually distinct editable fields, and a vertical-appropriate greeting and ' +
+                    'compliance footer.',
+                '2. Create it by calling `pitcher_email_template_create` with `{ instanceId, name, bodyHtml }` — ' +
+                    'pass the HTML **inline via `bodyHtml`** (a file path cannot cross a host\'s sandbox boundary, so always inline).',
+                '3. Report the created template id and name.',
+            ].join('\n');
+            return [{ role: 'user', content: { type: 'text', text } }];
+        },
+    },
+];

package/dist/src/mcp/prompts/registry.d.ts

@@ -0,0 +1,2 @@
+import type { PromptDescriptor } from './types.js';
+export declare const allPrompts: PromptDescriptor[];

package/dist/src/mcp/prompts/registry.js

@@ -0,0 +1,6 @@
+import { emailTemplatePrompts } from './emailTemplate.js';
+import { dsrLandingPrompts } from './dsrLanding.js';
+import { dsrPrompts } from './dsr.js';
+import { announcementsPrompts } from './announcements.js';
+// Every recipe prompt the server can expose. Mirrors mcp/registry.ts (allTools).
+export const allPrompts = [...emailTemplatePrompts, ...dsrLandingPrompts, ...dsrPrompts, ...announcementsPrompts];

package/dist/src/mcp/prompts/shared.d.ts

@@ -0,0 +1,3 @@
+export declare function instanceLine(instanceId: string | undefined): string;
+export declare function safetyPreamble(): string;
+export declare function recipePreamble(): string;

package/dist/src/mcp/prompts/shared.js

@@ -0,0 +1,31 @@
+import { CONTENT_DESIGN_PRINCIPLES } from '../resources/contentDesign.js';
+// Resolves the "which instance" line shared by every recipe prompt: echoes the given
+// id, or tells the model to discover + confirm one interactively.
+export function instanceLine(instanceId) {
+    return instanceId
+        ? `Target instance: ${instanceId}.`
+        : 'No instance was given — call `pitcher_instances_list`, pick the right one with the user, and confirm before creating.';
+}
+// Prod-awareness + anti-XSS guidance shared by EVERY recipe prompt (HTML-authoring or not).
+// Split out of recipePreamble so non-authoring workflow recipes (e.g. seed_dsr) can carry the
+// safety guidance without the HTML design principles. Contains the strings every prompt is
+// required to include: "demo/test instance", "{{token}}", "{{{ }}}".
+export function safetyPreamble() {
+    return [
+        '## Before you create',
+        'Confirm the resolved instance is a demo/test instance. These tools create **live, ' +
+            'org-visible** content; a DSR is served to **external, unauthenticated** viewers. Do not ' +
+            'seed against a real customer instance without explicit confirmation from the user.',
+        '',
+        '## Safe content',
+        'Put dynamic values through the platform `{{token}}` merge fields (the platform escapes them). ' +
+            'Never inline untrusted or CRM-derived strings as literal HTML, and never use triple-mustache ' +
+            '`{{{ }}}`. The use-case/vertical inputs are descriptive only — do not echo them verbatim into ' +
+            'the generated markup.',
+    ].join('\n');
+}
+// Full preamble for HTML-authoring recipes: the design principles + the safety guidance.
+// Authored once so the principles, prod-awareness, and anti-XSS guidance can't drift.
+export function recipePreamble() {
+    return [CONTENT_DESIGN_PRINCIPLES, '', safetyPreamble()].join('\n');
+}

package/dist/src/mcp/prompts/types.d.ts

@@ -0,0 +1,9 @@
+import type { ZodOptional, ZodString } from 'zod';
+import type { PromptMessage } from '@modelcontextprotocol/sdk/types.js';
+export interface PromptDescriptor {
+    name: string;
+    title: string;
+    description: string;
+    argsSchema: Record<string, ZodOptional<ZodString>>;
+    build: (args: Record<string, string | undefined>) => PromptMessage[];
+}

package/dist/src/mcp/prompts/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/mcp/resources/contentDesign.d.ts

@@ -0,0 +1,3 @@
+import type { ResourceDescriptor } from './types.js';
+export declare const CONTENT_DESIGN_PRINCIPLES = "# Pitcher content design principles\n\nDistilled guidance for authoring good Pitcher demo content. Apply these when generating\nemail templates and DSR landing pages.\n\n## 1. Palette \u2014 derive, never hardcode\nBuild a 6-tone ramp from the instance primary color rather than pasting brand hex codes:\ndarken 30% and 15% for accents/headers, lighten 15/30/60/80% for backgrounds and tints.\nThis keeps content on-brand across instances automatically.\n\n## 2. HTML email standards\n- Max width ~620px, centered in the viewport.\n- Table-based layout \u2014 NOT CSS grid/flex (email clients drop them).\n- All styles inline \u2014 no `<style>` block.\n- Exactly one clear call-to-action.\n- Make editable regions obvious: wrap them in a visually distinct container (colored\n  background, left border, an uppercase label above).\n- Every template needs a realistic demo story \u2014 a use case a sales rep would actually send.\n\n## 3. DSR landing-page standards\n- The HTML MUST contain the `data-pitcher-email-gate` marker (the platform injects the\n  email-gate form there at render time), or creation fails client-side.\n- Responsive without media queries: use `clamp(min, fluid, max)` for sizing plus\n  `flex-wrap: wrap`; that covers 320px to 1440px with no breakpoints.\n- Guard merge fields at the field level with sensible fallbacks, e.g. a default when\n  `{{rep.name}}` is absent.\n\n## 4. Band / bookend layout (shared canvas vocabulary)\n- Hero: full brand fill with a white title.\n- Content bands: alternate white and a faint brand tint; use generous padding.\n- Closing: a deeper brand fill.\n- Avoid the \"washed-out trap\" \u2014 inject real brand fills instead of relying on theme\n  presets that hard-code headings to black.\n\n## 5. Safe dynamic content (security \u2014 required)\nDynamic values go ONLY through the platform's `{{token}}` merge fields, which the platform\nescapes. Never inline untrusted or CRM-derived strings as literal HTML, and never use\ntriple-mustache `{{{ }}}`. DSR landing pages render to external, unauthenticated viewers,\nso unescaped dynamic HTML is a stored-XSS boundary. Descriptive inputs (a use case, a\nvertical) are for steering the design \u2014 do not echo them verbatim into the markup.\n\n## 6. Demo-story discipline (house rules)\n- Every artifact needs a realistic use case a rep would actually send.\n- No real vendor or competitor names.\n- Stats and figures are illustrative, not represented as real customer data.\n- All copy in English.\n";
+export declare const contentDesignResource: ResourceDescriptor;

package/dist/src/mcp/resources/contentDesign.js

@@ -0,0 +1,62 @@
+// Distilled Pitcher content-design nucleus. This is the SINGLE source: the resource
+// below returns it, and both recipe prompts (mcp/prompts/*) embed it inline (a URI
+// mention alone is not auto-fetched by MCP hosts, so prompts must carry the text).
+//
+// Distilled from the personal Claude Code skills `email-templates`, `dsr-landing-seed`,
+// and `playbook-seed` (palette/band vocabulary). Those skills remain the authoritative
+// deep version; keep this in sync on material design changes. Last synced: 2026-07-17.
+export const CONTENT_DESIGN_PRINCIPLES = `# Pitcher content design principles
+
+Distilled guidance for authoring good Pitcher demo content. Apply these when generating
+email templates and DSR landing pages.
+
+## 1. Palette — derive, never hardcode
+Build a 6-tone ramp from the instance primary color rather than pasting brand hex codes:
+darken 30% and 15% for accents/headers, lighten 15/30/60/80% for backgrounds and tints.
+This keeps content on-brand across instances automatically.
+
+## 2. HTML email standards
+- Max width ~620px, centered in the viewport.
+- Table-based layout — NOT CSS grid/flex (email clients drop them).
+- All styles inline — no \`<style>\` block.
+- Exactly one clear call-to-action.
+- Make editable regions obvious: wrap them in a visually distinct container (colored
+  background, left border, an uppercase label above).
+- Every template needs a realistic demo story — a use case a sales rep would actually send.
+
+## 3. DSR landing-page standards
+- The HTML MUST contain the \`data-pitcher-email-gate\` marker (the platform injects the
+  email-gate form there at render time), or creation fails client-side.
+- Responsive without media queries: use \`clamp(min, fluid, max)\` for sizing plus
+  \`flex-wrap: wrap\`; that covers 320px to 1440px with no breakpoints.
+- Guard merge fields at the field level with sensible fallbacks, e.g. a default when
+  \`{{rep.name}}\` is absent.
+
+## 4. Band / bookend layout (shared canvas vocabulary)
+- Hero: full brand fill with a white title.
+- Content bands: alternate white and a faint brand tint; use generous padding.
+- Closing: a deeper brand fill.
+- Avoid the "washed-out trap" — inject real brand fills instead of relying on theme
+  presets that hard-code headings to black.
+
+## 5. Safe dynamic content (security — required)
+Dynamic values go ONLY through the platform's \`{{token}}\` merge fields, which the platform
+escapes. Never inline untrusted or CRM-derived strings as literal HTML, and never use
+triple-mustache \`{{{ }}}\`. DSR landing pages render to external, unauthenticated viewers,
+so unescaped dynamic HTML is a stored-XSS boundary. Descriptive inputs (a use case, a
+vertical) are for steering the design — do not echo them verbatim into the markup.
+
+## 6. Demo-story discipline (house rules)
+- Every artifact needs a realistic use case a rep would actually send.
+- No real vendor or competitor names.
+- Stats and figures are illustrative, not represented as real customer data.
+- All copy in English.
+`;
+export const contentDesignResource = {
+    name: 'content-principles',
+    uri: 'pitcher://design/content-principles',
+    title: 'Pitcher content design principles',
+    description: 'Palette, HTML-email, DSR-landing, band-layout, and safe-token guidance for authoring content.',
+    mimeType: 'text/markdown',
+    read: () => CONTENT_DESIGN_PRINCIPLES,
+};

package/dist/src/mcp/resources/registry.d.ts

@@ -0,0 +1,2 @@
+import type { ResourceDescriptor } from './types.js';
+export declare const allResources: ResourceDescriptor[];

package/dist/src/mcp/resources/registry.js

@@ -0,0 +1,3 @@
+import { contentDesignResource } from './contentDesign.js';
+// Every resource the server can expose. Mirrors mcp/registry.ts (allTools).
+export const allResources = [contentDesignResource];

package/dist/src/mcp/resources/types.d.ts

@@ -0,0 +1,8 @@
+export interface ResourceDescriptor {
+    name: string;
+    uri: string;
+    title: string;
+    description: string;
+    mimeType: string;
+    read: () => string;
+}

package/dist/src/mcp/resources/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/mcp/result.d.ts

@@ -9,5 +9,6 @@ export interface CallToolResultShape {
     isError: boolean;
     [key: string]: unknown;
 }
+export declare const MAX_RESULT_BYTES = 900000;
 export declare function toErrorResult(code: string, message: string): CallToolResultShape;
-export declare function envelopeToToolResult(env: Envelope<unknown>): CallToolResultShape;
+export declare function envelopeToToolResult(env: Envelope<unknown>, maxBytes?: number): CallToolResultShape;

package/dist/src/mcp/result.js

@@ -1,20 +1,80 @@
+// MCP hosts cap a single tool result (Claude Desktop: 1 MB). We stay well under it,
+// leaving headroom for JSON-RPC framing, warning blocks, and multi-byte characters.
+export const MAX_RESULT_BYTES = 900000;
+// Cap any single variable-length string (a server error message, a warning) so one huge value
+// can't blow the size budget regardless of which tier it lands in.
+const MAX_TEXT_BYTES = 8000;
+function clampText(s) {
+    return Buffer.byteLength(s, 'utf8') <= MAX_TEXT_BYTES ? s : `${s.slice(0, MAX_TEXT_BYTES)}… (truncated)`;
+}
 function isPlainObject(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
+// Best-effort item count for the "too large" guidance, without assuming a payload shape.
+function countItems(data) {
+    if (Array.isArray(data))
+        return data.length;
+    if (isPlainObject(data) && Array.isArray(data.results))
+        return data.results.length;
+    return undefined;
+}
 export function toErrorResult(code, message) {
-    return { content: [{ type: 'text', text: `${code}: ${message}` }], isError: true };
+    return { content: [{ type: 'text', text: clampText(`${code}: ${message}`) }], isError: true };
 }
-export function envelopeToToolResult(env) {
+export function envelopeToToolResult(env, maxBytes = MAX_RESULT_BYTES) {
     if (!env.ok) {
         return toErrorResult(env.error?.code ?? 'UNKNOWN', env.error?.message ?? 'unknown error');
     }
-    const text = env.data === undefined ? 'null' : JSON.stringify(env.data);
-    const content = [{ type: 'text', text }];
-    for (const w of env.warnings ?? [])
-        content.push({ type: 'text', text: `warning: ${w}` });
-    const result = { content, isError: false };
-    // structuredContent must be an object; omit for arrays/primitives (text still carries the data).
-    if (isPlainObject(env.data))
-        result.structuredContent = env.data;
-    return result;
+    const full = env.data === undefined ? 'null' : JSON.stringify(env.data);
+    const bytes = Buffer.byteLength(full, 'utf8');
+    // structuredContent must be an object; arrays/primitives ride in the text block only.
+    const obj = isPlainObject(env.data) ? env.data : undefined;
+    const withWarnings = (content) => {
+        for (const w of env.warnings ?? [])
+            content.push({ type: 'text', text: clampText(`warning: ${w}`) });
+        return content;
+    };
+    // Measure the ACTUAL serialized size of a candidate result — JSON re-escaping (a payload copied
+    // into content.text is escaped a second time), warning blocks, keys, and structure are all
+    // counted — rather than projecting from the raw data size. maxBytes keeps headroom under the
+    // host cap for the outer JSON-RPC framing around this result.
+    const fits = (candidate) => Buffer.byteLength(JSON.stringify(candidate), 'utf8') <= maxBytes;
+    // Tier 1: full payload with the default dual representation (text + structuredContent).
+    const dual = { content: withWarnings([{ type: 'text', text: full }]), isError: false };
+    if (obj)
+        dual.structuredContent = obj;
+    if (fits(dual))
+        return dual;
+    const kb = Math.round(bytes / 1024);
+    const count = countItems(env.data);
+    const countPhrase = count === undefined ? '' : ` (${count} item${count === 1 ? '' : 's'})`;
+    // Tier 2: the payload fits once but not twice — keep it in structuredContent, drop the text dup.
+    if (obj) {
+        const note = `Large result${countPhrase} (~${kb} KB) returned in structuredContent; not duplicated as text to stay under the host's tool-result size limit.`;
+        const structuredOnly = {
+            content: withWarnings([{ type: 'text', text: note }]),
+            structuredContent: obj,
+            isError: false,
+        };
+        if (fits(structuredOnly))
+            return structuredOnly;
+    }
+    // Tier 3: even a single copy exceeds the limit — return a summary + guidance instead of an
+    // unusable dump the host would reject outright.
+    const limitKb = Math.round(maxBytes / 1024);
+    const guidance = `Result too large to return${countPhrase}: ~${kb} KB exceeds the ~${limitKb} KB tool-result limit. ` +
+        `Narrow the request — add filters, fetch a specific item by id, or use a smaller page-size — then retry.`;
+    const summary = { truncated: true, sizeBytes: bytes, limitBytes: maxBytes };
+    if (count !== undefined)
+        summary.count = count;
+    const summaryResult = {
+        content: withWarnings([{ type: 'text', text: guidance }]),
+        structuredContent: summary,
+        isError: false,
+    };
+    if (fits(summaryResult))
+        return summaryResult;
+    // Last resort (e.g. many warnings): drop the warnings — guidance + summary are always tiny, so
+    // this is guaranteed size-compliant rather than returning a result the host would reject.
+    return { content: [{ type: 'text', text: guidance }], structuredContent: summary, isError: false };
 }

package/dist/src/mcp/serve.d.ts

@@ -1 +1,4 @@
-export declare function runMcpServe(env?: NodeJS.ProcessEnv): Promise<void>;
+import type { ToolDescriptor } from './tools/types.js';
+import type { PromptDescriptor } from './prompts/types.js';
+import type { ResourceDescriptor } from './resources/types.js';
+export declare function runMcpServe(env?: NodeJS.ProcessEnv, tools?: ToolDescriptor[], prompts?: PromptDescriptor[], resources?: ResourceDescriptor[]): Promise<void>;

package/dist/src/mcp/serve.js

@@ -2,12 +2,17 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { resolveMcpEnv } from './env.js';
 import { buildServer } from './server.js';
 import { allTools } from './registry.js';
+import { allPrompts } from './prompts/registry.js';
+import { allResources } from './resources/registry.js';
 // Resolves auth/env, builds the server, connects stdio. Never writes to stdout except protocol frames.
-export async function runMcpServe(env = process.env) {
+// `tools` defaults to the full set (the CLI `p mcp`); the .mcpb bundle passes a curated subset.
+// Prompts/resources default to the full set for every frontend (no subsetting).
+export async function runMcpServe(env = process.env, tools = allTools, prompts = allPrompts, resources = allResources) {
     const mcpEnv = resolveMcpEnv(env);
-    const server = buildServer(mcpEnv);
+    const server = buildServer(mcpEnv, tools, prompts, resources);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     const target = mcpEnv.url ?? `https://${mcpEnv.org}.my.pitcher.com`;
-    console.error(`[pitcher-mcp] serving ${allTools.length} tools against ${target}${mcpEnv.prod ? ' (prod: destructive-hints on)' : ''}`);
+    console.error(`[pitcher-mcp] serving ${tools.length} tools, ${prompts.length} prompts, ${resources.length} resources ` +
+        `against ${target}${mcpEnv.prod ? ' (prod: destructive-hints on)' : ''}`);
 }

package/dist/src/mcp/server.d.ts

@@ -1,3 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { McpEnv } from './env.js';
-export declare function buildServer(env: McpEnv): McpServer;
+import type { ToolDescriptor } from './tools/types.js';
+import type { PromptDescriptor } from './prompts/types.js';
+import type { ResourceDescriptor } from './resources/types.js';
+export declare function buildServer(env: McpEnv, tools?: ToolDescriptor[], prompts?: PromptDescriptor[], resources?: ResourceDescriptor[]): McpServer;

package/dist/src/mcp/server.js

@@ -3,9 +3,16 @@ import { readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { allTools } from './registry.js';
+import { allPrompts } from './prompts/registry.js';
+import { allResources } from './resources/registry.js';
 import { envelopeToToolResult, toErrorResult } from './result.js';
 import { isCliError } from '../core/errors.js';
 const version = (() => {
+    // The .mcpb bundle inlines this at build time (esbuild define) because the bundled single
+    // file has no package.json to walk to. Undefined at CLI runtime → the readFileSync path below.
+    const injected = process.env.PITCHER_CLI_VERSION;
+    if (injected)
+        return injected;
     try {
         const dir = dirname(fileURLToPath(import.meta.url));
         return JSON.parse(readFileSync(join(dir, '..', '..', '..', 'package.json'), 'utf8')).version ?? '0.0.0';
@@ -15,9 +22,26 @@ const version = (() => {
         return '0.0.0';
     }
 })();
-export function buildServer(env) {
-    const server = new McpServer({ name: 'pitcher', version });
-    for (const tool of allTools) {
+// Connector branding shown by MCP hosts (Claude Desktop, Cursor). Self-contained
+// data URI so it needs no network/asset resolution: a navy (#29335C) tile with a
+// white "P" and the Pitcher-red (#CC0000) accent from the wordmark.
+const icon = 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA1MTIgNTEyIiB3aWR0aD0iNTEyIiBoZWlnaHQ9IjUxMiI+PHJlY3Qgd2lkdGg9IjUxMiIgaGVpZ2h0PSI1MTIiIHJ4PSIxMTYiIGZpbGw9IiMyOTMzNUMiLz48Y2lyY2xlIGN4PSIzNzIiIGN5PSIxNTAiIHI9IjMwIiBmaWxsPSIjQ0MwMDAwIi8+PHBhdGggZmlsbD0iI2ZmZmZmZiIgZD0iTTE1MCAxMTZoOTZhOTIgOTIgMCAwIDEgMCAxODRoLTUwdjk2aC00NnoiLz48cGF0aCBmaWxsPSIjMjkzMzVDIiBkPSJNMTk2IDE2MHY5Nmg1MGE0OCA0OCAwIDAgMCAwLTk2eiIvPjwvc3ZnPg==';
+// Compact, sanitized error string (no raw stack) — shared by the prompt/resource callbacks.
+function errorText(e) {
+    if (isCliError(e))
+        return `${e.code}: ${e.message}`;
+    return e instanceof Error ? e.message : String(e);
+}
+export function buildServer(env, tools = allTools, prompts = allPrompts, resources = allResources) {
+    const server = new McpServer({
+        name: 'pitcher',
+        version,
+        title: 'Pitcher',
+        description: 'Search, manage, and share Pitcher content, canvases, files, DSRs, and instances.',
+        websiteUrl: 'https://www.pitcher.com',
+        icons: [{ src: icon, mimeType: 'image/svg+xml', sizes: ['any'] }],
+    });
+    for (const tool of tools) {
         const destructive = tool.alwaysDestructive === true || (tool.write === true && env.prod);
         server.registerTool(tool.name, {
             title: tool.title,
@@ -37,5 +61,28 @@ export function buildServer(env) {
             }
         });
     }
+    for (const prompt of prompts) {
+        server.registerPrompt(prompt.name, { title: prompt.title, description: prompt.description, argsSchema: prompt.argsSchema }, (args) => {
+            try {
+                return { messages: prompt.build(args) };
+            }
+            catch (e) {
+                // build() is pure string assembly, but guard defensively: prompts have no result-level
+                // error channel (unlike tools), so surface failures by throwing — the SDK converts a
+                // thrown error into a JSON-RPC error. Re-throw a sanitized message (no raw stack).
+                throw new Error(`prompt "${prompt.name}" failed: ${errorText(e)}`);
+            }
+        });
+    }
+    for (const resource of resources) {
+        server.registerResource(resource.name, resource.uri, { title: resource.title, description: resource.description, mimeType: resource.mimeType }, (uri) => {
+            try {
+                return { contents: [{ uri: uri.href, mimeType: resource.mimeType, text: resource.read() }] };
+            }
+            catch (e) {
+                throw new Error(`resource "${resource.name}" failed: ${errorText(e)}`);
+            }
+        });
+    }
     return server;
 }

package/dist/src/mcp/tools/canvases.js

@@ -1,30 +1,97 @@
 import { z } from 'zod';
 import { runCanvasesList, runCanvasesGet } from '../../commands/canvases.js';
+// The five real canvas types, derived from the (is_section, is_template, is_block) flags.
+// One stable enum the model can filter and reason on — independent of any per-instance display
+// label an admin may configure for these in the UI.
+const CANVAS_TYPES = ['presentation', 'template', 'section', 'section_template', 'block'];
+function canvasType(c) {
+    if (c.is_block === true)
+        return 'block';
+    if (c.is_section === true && c.is_template === true)
+        return 'section_template';
+    if (c.is_template === true)
+        return 'template';
+    if (c.is_section === true)
+        return 'section';
+    return 'presentation';
+}
+// type → the explicit flag filter the Django canvases endpoint understands (false is honored server-side).
+// Non-block types pin isBlock:false so the canonical filter is unambiguous even if a caller also
+// passed a conflicting legacy flag.
+const TYPE_FLAGS = {
+    presentation: { isSection: false, isTemplate: false, isBlock: false },
+    template: { isSection: false, isTemplate: true, isBlock: false },
+    section: { isSection: true, isTemplate: false, isBlock: false },
+    section_template: { isSection: true, isTemplate: true, isBlock: false },
+    block: { isBlock: true },
+};
+// Tag a canvas object with its derived `type`; leave non-objects as-is. Spread `...c` FIRST so
+// the derived value always wins — if the API payload ever carries its own `type`, our canonical
+// enum must not be clobbered by it (JSON key order is cosmetic; correctness needs derived-last).
+function withType(c) {
+    if (c && typeof c === 'object' && !Array.isArray(c))
+        return { ...c, type: canvasType(c) };
+    return c;
+}
+// Wrapper: maps the `type` filter to explicit flags, then tags each returned canvas with its derived
+// `type`. Non-ok envelopes pass through untouched. `wraps` lets the coverage guard match by identity.
+async function runCanvasesListTyped(opts, deps) {
+    // Pull the legacy flags out of rest so a canonical `type` can override them entirely — otherwise
+    // e.g. `type: 'presentation'` + `isBlock: true` would still send is_block=true and return blocks.
+    const { type, isSection, isTemplate, isBlock, ...rest } = opts;
+    const flags = typeof type === 'string' && type in TYPE_FLAGS ? TYPE_FLAGS[type] : { isSection, isTemplate, isBlock };
+    const env = await runCanvasesList({ ...rest, ...flags }, deps);
+    if (!env.ok)
+        return env;
+    const data = env.data;
+    if (Array.isArray(data?.results))
+        return { ...env, data: { ...data, results: data.results.map(withType) } };
+    return env;
+}
+async function runCanvasesGetTyped(opts, deps) {
+    const env = await runCanvasesGet(opts, deps);
+    if (!env.ok)
+        return env;
+    return { ...env, data: withType(env.data) };
+}
 export const canvasesTools = [
     {
         name: 'pitcher_canvases_list',
         title: 'List canvases',
-        description: 'List canvases (presentations, sections, blocks) in an instance. Use to discover canvas IDs before sharing or reading. Blocks are hidden unless isBlock is true.',
+        description: 'List canvases in an instance and discover their IDs. Each canvas is one of five types (returned as `type`): ' +
+            "presentation (a rep's finished deck), template (a reusable starter deck), section (a single slide / product " +
+            'module), section_template (a reusable section), or block (a reusable component group). ' +
+            'Filter to one with `type` (preferred) — e.g. type="presentation" for finished decks, type="template" for templates. ' +
+            'With no filter, presentations + templates + sections come back together and blocks are hidden. ' +
+            'Some instances rename these types in their UI (e.g. section → "Slide"); pitcher_instances_info returns a ' +
+            '`terminology` map — use those labels when addressing the user, but keep filtering on the canonical `type`.',
         inputShape: {
             instanceId: z.string().describe('Instance ID (required)'),
-            isTemplate: z.boolean().optional().describe('Only templates'),
-            isSection: z.boolean().optional().describe('Only sections'),
-            isBlock: z.boolean().optional().describe('Only blocks (hidden unless set)'),
+            type: z
+                .enum(CANVAS_TYPES)
+                .optional()
+                .describe('Filter to one canvas type (preferred over the is* flags): presentation | template | section | section_template | block'),
+            isTemplate: z.boolean().optional().describe('Legacy flag filter; prefer `type`'),
+            isSection: z.boolean().optional().describe('Legacy flag filter; prefer `type`'),
+            isBlock: z.boolean().optional().describe('Legacy flag filter; prefer `type`. Blocks are hidden unless set'),
             tags: z.string().optional().describe('Comma-separated tags'),
             idIn: z.string().optional().describe('Comma-separated canvas IDs'),
             accessType: z.enum(['public', 'restricted', 'personal']).optional(),
             page: z.number().int().optional(),
             pageSize: z.number().int().optional().describe('Page size (max 500)'),
         },
-        run: runCanvasesList,
+        run: runCanvasesListTyped,
+        wraps: runCanvasesList,
         readOnly: true,
     },
     {
         name: 'pitcher_canvases_get',
         title: 'Get a canvas',
-        description: 'Retrieve a single canvas by its ID.',
+        description: 'Retrieve a single canvas by its ID. The returned object includes a derived `type` ' +
+            '(presentation, template, section, section_template, or block).',
         inputShape: { id: z.string().describe('Canvas ID') },
-        run: runCanvasesGet,
+        run: runCanvasesGetTyped,
+        wraps: runCanvasesGet,
         readOnly: true,
     },
 ];

package/dist/src/mcp/tools/dsrLanding.js

@@ -9,8 +9,16 @@ export const dsrLandingTools = [
         inputShape: {
             instanceId: z.string().describe('Instance ID (required)'),
             name: z.string().describe('Template name (required)'),
-            htmlFile: z.string().describe('Path to the landing HTML (required; must contain data-pitcher-email-gate)'),
-            cssFile: z.string().optional().describe('Path to a CSS file for the template'),
+            html: z
+                .string()
+                .optional()
+                .describe('Inline landing HTML (must contain data-pitcher-email-gate). Use this OR htmlFile — prefer this in hosts without a shared filesystem, e.g. Claude Desktop.'),
+            htmlFile: z
+                .string()
+                .optional()
+                .describe('Path to the landing HTML (must contain data-pitcher-email-gate). Use this OR html.'),
+            css: z.string().optional().describe('Inline CSS for the template. Use this OR cssFile.'),
+            cssFile: z.string().optional().describe('Path to a CSS file for the template. Use this OR css.'),
             mergeSchema: z.string().optional().describe('Merge schema JSON array as a string'),
             thumbnailUrl: z.string().optional().describe('Thumbnail image URL'),
             language: z.string().optional().describe('Language code (max 10 chars)'),

package/dist/src/mcp/tools/emailTemplate.js

@@ -8,6 +8,10 @@ export const emailTemplateTools = [
         inputShape: {
             instanceId: z.string().describe('Instance ID (required)'),
             name: z.string().describe('Template name (required)'),
+            bodyHtml: z
+                .string()
+                .optional()
+                .describe('Inline HTML body (inline CSS). Use this OR bodyFile — prefer this in hosts without a shared filesystem, e.g. Claude Desktop.'),
             bodyFile: z.string().optional().describe('Path to an HTML file (inline CSS) used as the template body'),
             subject: z.string().optional().describe('Email subject (supports {{tokens}})'),
             tags: z.string().optional().describe('Tags JSON object as a string'),

package/dist/src/mcp/tools/instances.js

@@ -1,5 +1,56 @@
 import { z } from 'zod';
 import { runInstancesList, runInstancesInfo } from '../../commands/instances.js';
+// An instance's settings.translation_overrides (keyed by language, using Pitcher's UI keys) lets an
+// admin relabel the canvas types in their UI — e.g. section → "Slide", canvas → "PitchDeck". Map those
+// onto the canonical canvas `type` names so the model can address the user in each instance's own
+// vocabulary while still reasoning/filtering on the stable `type`. Zero extra calls — the overrides are
+// already in the instance payload.
+function terminologyFromOverrides(overrides) {
+    var _a;
+    if (!overrides || typeof overrides !== 'object')
+        return undefined;
+    const out = {};
+    for (const [lang, raw] of Object.entries(overrides)) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        // Fold keys to lowercase: the platform's override engine matches dotless keys
+        // case-insensitively (RegExp('\\b'+key+'\\b','gi') in canvas-ui translations.ts), and real
+        // instances do use e.g. `CANVAS`. First occurrence wins on a (theoretical) case collision.
+        const m = {};
+        for (const [k, v] of Object.entries(raw))
+            m[_a = k.toLowerCase()] ?? (m[_a] = v);
+        const labels = {};
+        const put = (type, ...keys) => {
+            for (const k of keys) {
+                const v = m[k];
+                if (typeof v === 'string' && v) {
+                    labels[type] = v;
+                    return;
+                }
+            }
+        };
+        put('presentation', 'canvas');
+        put('section', 'section');
+        put('template', 'nav.templates', 'navigation.templates');
+        put('block', 'nav.blocks', 'navigation.blocks');
+        if (Object.keys(labels).length)
+            out[lang] = labels;
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+// Wrapper: attach a normalized `terminology` map derived from the instance's translation_overrides,
+// so the model knows what this customer calls each canvas type. `wraps` keeps the coverage guard happy.
+async function runInstancesInfoWithTerminology(opts, deps) {
+    const env = await runInstancesInfo(opts, deps);
+    if (!env.ok || !env.data || typeof env.data !== 'object')
+        return env;
+    const data = env.data;
+    const settings = data.settings;
+    const terminology = terminologyFromOverrides(settings?.translation_overrides);
+    if (!terminology)
+        return env;
+    return { ...env, data: { ...data, terminology } };
+}
 export const instancesTools = [
     {
         name: 'pitcher_instances_list',
@@ -19,10 +70,13 @@ export const instancesTools = [
     {
         name: 'pitcher_instances_info',
         title: 'Get an instance',
-        description: 'Retrieve details for a single instance by its ID.' +
-            ' Output may include raw instance settings/metadata (potentially integration credentials) - treat as sensitive.',
+        description: 'Retrieve details for a single instance by its ID. If the instance renames canvas types in its UI, a ' +
+            'normalized `terminology` map is included ({ <lang>: { presentation, section, template, block } }, e.g. ' +
+            'section → "Slide") — use those labels when addressing the user, but keep filtering/reasoning on the canonical ' +
+            'canvas `type`. Output may include raw instance settings/metadata (potentially integration credentials) - treat as sensitive.',
         inputShape: { id: z.string().describe('Instance ID') },
-        run: runInstancesInfo,
+        run: runInstancesInfoWithTerminology,
+        wraps: runInstancesInfo,
         readOnly: true,
     },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pitcher/cli-scripts",
-  "version": "2.9.0",
+  "version": "2.11.0",
   "description": "The Pitcher CLI for various tasks in its ecosystem.",
   "author": "Pitcher AG",
   "license": "MIT",
@@ -14,9 +14,11 @@
   "types": "./dist/index.d.ts",
   "scripts": {
     "build": "tsc",
+    "type-check": "tsc --noEmit && tsc -p mcpb/tsconfig.json",
     "test": "vitest run",
     "test:watch": "vitest",
-    "prepublishOnly": "yarn build"
+    "prepublishOnly": "yarn build",
+    "mcpb:pack": "tsc -p mcpb/tsconfig.json && node mcpb/build.mjs"
   },
   "bin": {
     "p": "./dist/index.js"
@@ -25,8 +27,10 @@
     "dist"
   ],
   "devDependencies": {
+    "@anthropic-ai/mcpb": "^2.1.2",
     "@types/archiver": "^7.0.0",
     "@types/node": "^24.13.2",
+    "esbuild": "^0.28.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.9"
   },