@pitcher/cli-scripts 2.8.0 → 2.10.0

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

@@ -0,0 +1,14 @@
+import type { Envelope } from '../core/envelope.js';
+export interface ToolTextContent {
+    type: 'text';
+    text: string;
+}
+export interface CallToolResultShape {
+    content: ToolTextContent[];
+    structuredContent?: Record<string, unknown>;
+    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>, maxBytes?: number): CallToolResultShape;

package/dist/src/mcp/result.js

@@ -0,0 +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: clampText(`${code}: ${message}`) }], isError: true };
+}
+export function envelopeToToolResult(env, maxBytes = MAX_RESULT_BYTES) {
+    if (!env.ok) {
+        return toErrorResult(env.error?.code ?? 'UNKNOWN', env.error?.message ?? 'unknown error');
+    }
+    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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,18 @@
+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.
+// `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, 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 ${tools.length} tools, ${prompts.length} prompts, ${resources.length} resources ` +
+        `against ${target}${mcpEnv.prod ? ' (prod: destructive-hints on)' : ''}`);
+}

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

@@ -0,0 +1,6 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpEnv } from './env.js';
+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

@@ -0,0 +1,88 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+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';
+    }
+    catch {
+        // cosmetic server version; fall back if package.json is unreadable
+        return '0.0.0';
+    }
+})();
+// 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,
+            description: tool.description,
+            inputSchema: tool.inputShape,
+            annotations: { readOnlyHint: tool.readOnly, destructiveHint: destructive },
+        }, async (args) => {
+            try {
+                // spread args FIRST so injected auth/env always wins — never reorder to { apiKey, ...args }
+                const envelope = await tool.run({ ...args, apiKey: env.apiKey, org: env.org, url: env.url });
+                return envelopeToToolResult(envelope);
+            }
+            catch (e) {
+                const code = isCliError(e) ? e.code : 'UNKNOWN';
+                const message = isCliError(e) ? e.message : e instanceof Error ? e.message : String(e);
+                return toErrorResult(code, message);
+            }
+        });
+    }
+    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/analytics.d.ts

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

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { runAnalyticsOrg, runAnalyticsInstance } from '../../commands/analytics.js';
+export const analyticsTools = [
+    {
+        name: 'pitcher_analytics_org',
+        title: 'Org analytics rollups',
+        description: 'Read organization-wide analytics rollup totals. Requires an org-admin API key.',
+        inputShape: {},
+        run: runAnalyticsOrg,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_analytics_instance',
+        title: 'Instance analytics rollups',
+        description: 'Read analytics rollup totals for a single instance. Requires an instance-admin or org-admin API key.',
+        inputShape: { instanceId: z.string().describe('Instance ID (required)') },
+        run: runAnalyticsInstance,
+        readOnly: true,
+    },
+];

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

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

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { runAnnouncementsCreate, runAnnouncementsList } from '../../commands/announcements.js';
+export const announcementsTools = [
+    {
+        name: 'pitcher_announcements_create',
+        title: 'Create an announcement',
+        description: 'Create a wa-announcements appsDB record (title/body, optional media, CTA link, scheduling, group targeting). ' +
+            'Requires either fromFile (a JSON object with the announcement data) or both title and body. Additive.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            fromFile: z.string().optional().describe('Path to a JSON file with the announcement data object'),
+            title: z.string().optional().describe('Announcement title (overrides a matching fromFile key)'),
+            body: z.string().optional().describe('Announcement body HTML (overrides a matching fromFile key)'),
+            priority: z.string().optional().describe("Priority, e.g. 'normal' or 'important' (overrides a matching fromFile key)"),
+        },
+        run: runAnnouncementsCreate,
+        readOnly: false,
+        write: true,
+    },
+    {
+        name: 'pitcher_announcements_list',
+        title: 'List announcements',
+        description: 'List wa-announcements appsDB records for an instance.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            limit: z.number().int().optional(),
+            offset: z.number().int().optional(),
+        },
+        run: runAnnouncementsList,
+        readOnly: true,
+    },
+];

package/dist/src/mcp/tools/canvases.d.ts

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

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

@@ -0,0 +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 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)'),
+            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: runCanvasesListTyped,
+        wraps: runCanvasesList,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_canvases_get',
+        title: 'Get a canvas',
+        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: runCanvasesGetTyped,
+        wraps: runCanvasesGet,
+        readOnly: true,
+    },
+];

package/dist/src/mcp/tools/devSync.d.ts

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

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { runDevSync, runRevert } from '../../commands/devSync.js';
+import { fail } from '../../core/envelope.js';
+import { createCliError } from '../../core/errors.js';
+// devSync.ts is legacy-shaped: `DevSyncOptions.fileId` is a required (non-optional)
+// string, unlike every other command's `CommonOpts & { field?: ... }` + in-run
+// VALIDATION-throw pattern. That mismatch means `runDevSync`/`runRevert` cannot be
+// assigned directly to `ToolDescriptor.run` (typed `Record<string, unknown> &
+// InjectedAuth`) — TS reports `fileId` as missing. These thin wrappers narrow the
+// runtime value (the MCP zod schema already guarantees it's a string) and forward
+// a properly-typed object literal, instead of casting the whole `opts` blob.
+function requireFileId(opts) {
+    return typeof opts.fileId === 'string' ? opts.fileId : undefined;
+}
+export const devSyncTools = [
+    {
+        name: 'pitcher_dev_sync',
+        title: 'Dev-sync an app (one-shot)',
+        description: 'One-time sync of a local app build (a folder with app.json, on the MCP server host — cwd or ./dist) ' +
+            'to S3 as a live dev override for an installed app file, for testing without publishing. ' +
+            'This is a single sync, not the continuous watcher — call again to re-sync after further changes. ' +
+            'Reversible with pitcher_dev_sync_revert.',
+        inputShape: {
+            fileId: z.string().describe('File ID of the installed app (pitcher_file.id) to override'),
+        },
+        run: (opts, deps) => {
+            const fileId = requireFileId(opts);
+            if (!fileId)
+                return Promise.resolve(fail(createCliError('VALIDATION', 'fileId is required')));
+            return runDevSync({ fileId, apiKey: opts.apiKey, org: opts.org }, deps);
+        },
+        wraps: runDevSync,
+        readOnly: false,
+        write: true,
+    },
+    {
+        name: 'pitcher_dev_sync_revert',
+        title: 'Revert a dev-sync override',
+        description: 'Revert a dev-sync override on an installed app file, restoring its original published version.',
+        inputShape: {
+            fileId: z.string().describe('File ID of the installed app (pitcher_file.id) to revert'),
+        },
+        run: (opts, deps) => {
+            const fileId = requireFileId(opts);
+            if (!fileId)
+                return Promise.resolve(fail(createCliError('VALIDATION', 'fileId is required')));
+            return runRevert({ fileId, apiKey: opts.apiKey, org: opts.org }, deps);
+        },
+        wraps: runRevert,
+        readOnly: false,
+        write: true,
+    },
+];

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

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

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

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { runDsrCreate, runDsrBindLanding } from '../../commands/dsr.js';
+const AUTH_STRATEGIES = [
+    'none', 'any_email', 'specified_emails', 'specified_domains', 'verified_emails', 'verified_domains',
+];
+export const dsrTools = [
+    {
+        name: 'pitcher_dsr_create',
+        title: 'Create and share a DSR',
+        description: 'Create a Digital Sales Room (a canvas share link) and get a clickable link back. Source is a canvas (canvasId) OR files (shareboxFileIds) - exactly one. Optional email/domain gating and a bound landing-page template. Never hard-fails once a link exists: a failed landing bind returns the link with a warning. Additive.',
+        inputShape: {
+            instanceId: z.string().optional().describe('Instance ID (required for the shareboxFileIds source)'),
+            canvasId: z.string().optional().describe('Canvas to share (exactly one of canvasId / shareboxFileIds)'),
+            shareboxFileIds: z.array(z.string()).optional().describe('File IDs to build a share from (exactly one of canvasId / shareboxFileIds)'),
+            canvasName: z.string().optional().describe('Name for the ShareBox-built canvas'),
+            accountId: z.string().optional(),
+            templateId: z.string().optional(),
+            authStrategy: z.enum(AUTH_STRATEGIES).optional().describe('Access gating (server default any_email)'),
+            allowedEmails: z.array(z.string()).optional().describe('Required for specified_emails / verified_emails'),
+            allowedDomains: z.array(z.string()).optional().describe('Required for specified_domains / verified_domains'),
+            validUntil: z.string().optional().describe('Expiry, ISO datetime'),
+            allowForward: z.boolean().optional(),
+            allowDownload: z.boolean().optional(),
+            tags: z.array(z.string()).optional(),
+            landingTemplateId: z.string().optional().describe('Bind a landing-page template (discover via pitcher_dsr_landing_list)'),
+            landingContext: z.string().optional().describe('Landing-page merge fields, a JSON object as a string'),
+            configFile: z.string().optional().describe('Path on the MCP server host to a full {source,security,landing} spec JSON; mutually exclusive with the individual flags'),
+        },
+        run: runDsrCreate,
+        readOnly: false,
+        write: true,
+    },
+    {
+        name: 'pitcher_dsr_bind_landing',
+        title: 'Bind a DSR landing page',
+        description: 'Attach, re-brand, or unbind a landing-page template on an existing DSR share. Use landingTemplateId "none" to unbind. Requires an editor-level key (hard-fails AUTH otherwise).',
+        inputShape: {
+            id: z.string().describe('Shared-link ID'),
+            landingTemplateId: z.string().describe('Landing template ID, or "none" to unbind'),
+            landingContext: z.string().optional().describe('Landing-page merge fields, a JSON object as a string'),
+            instanceId: z.string().optional(),
+        },
+        run: runDsrBindLanding,
+        readOnly: false,
+        write: true,
+    },
+];

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

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

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { runDsrLandingCreate, runDsrLandingSetDefault, runDsrLandingList } from '../../commands/dsrLanding.js';
+export const dsrLandingTools = [
+    {
+        name: 'pitcher_dsr_landing_create',
+        title: 'Create a DSR landing template',
+        description: 'Create a DSR (Digital Sales Room) landing-page template from HTML (must contain the data-pitcher-email-gate ' +
+            'marker) and optional CSS/merge-schema/thumbnail. Optionally set it as the instance default in the same call. Additive.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            name: z.string().describe('Template name (required)'),
+            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)'),
+            default: z.boolean().optional().describe('Also set this template as the instance-scope default after creating it'),
+        },
+        run: runDsrLandingCreate,
+        readOnly: false,
+        write: true,
+    },
+    {
+        name: 'pitcher_dsr_landing_set_default',
+        title: 'Set default DSR landing template',
+        description: 'Set an existing DSR landing-page template as the instance-scope default.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            id: z.string().describe('Template ID (required)'),
+        },
+        run: runDsrLandingSetDefault,
+        readOnly: false,
+        write: true,
+    },
+    {
+        name: 'pitcher_dsr_landing_list',
+        title: 'List DSR landing templates',
+        description: 'List DSR (Digital Sales Room) landing-page templates in an instance.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+        },
+        run: runDsrLandingList,
+        readOnly: true,
+    },
+];

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

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

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

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { runEmailTemplateCreate, runEmailTemplateList, runEmailTemplateGet } from '../../commands/emailTemplate.js';
+export const emailTemplateTools = [
+    {
+        name: 'pitcher_email_template_create',
+        title: 'Create an email template',
+        description: 'Create an HTML email template for the emails app (Rep Triggered Emails). Additive.',
+        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'),
+            metadata: z.string().optional().describe('Metadata JSON object as a string'),
+        },
+        run: runEmailTemplateCreate,
+        readOnly: false,
+        write: true,
+    },
+    {
+        name: 'pitcher_email_template_list',
+        title: 'List email templates',
+        description: 'List HTML email templates for the emails app in an instance. Filter by name, status, category, or target.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            name: z.string().optional().describe('Case-insensitive substring filter, matched against name OR subject'),
+            status: z.string().optional().describe('Status filter'),
+            category: z.string().optional().describe('Category filter'),
+            target: z.string().optional().describe('Target filter'),
+            limit: z.number().int().optional(),
+            offset: z.number().int().optional(),
+        },
+        run: runEmailTemplateList,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_email_template_get',
+        title: 'Get an email template',
+        description: 'Retrieve a single HTML email template by its ID.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            id: z.string().describe('Template ID (required)'),
+        },
+        run: runEmailTemplateGet,
+        readOnly: true,
+    },
+];

package/dist/src/mcp/tools/files.d.ts

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