@pitcher/cli-scripts 2.8.0 → 2.9.0

package/README.md

@@ -10,6 +10,43 @@ p --help
 p command --help
 ```
 
+## MCP server
+
+Run `p mcp` to start a stdio [MCP](https://modelcontextprotocol.io) server that exposes this CLI's commands as tools to an MCP-capable host (Claude Desktop, Claude Code, etc). It wraps 50 tools, one per CLI `run*` function: every command above (including `dsr create` + `dsr bind-landing`) except the five local `scaffold` subcommands (which just print/write a starter file and make no request). `dev-sync` is exposed as a one-shot sync only; the continuous `watch` mode is not available as a tool.
+
+```bash
+p mcp
+# or without a global install
+npx @pitcher/cli-scripts mcp
+```
+
+### Environment variables
+
+Auth and org scope are resolved once at boot from environment variables. They are never tool inputs, so the model cannot change org or credentials mid-session.
+
+- `NG_API_KEY` (required, secret): the API key the server authenticates as.
+- `NG_ORG` (default `dev`): organization subdomain, or set `NG_URL` directly for a full origin.
+- `NG_ENV` (`prod` or `test`): controls the destructive-hint guard on write tools (see below). Defaults to a guess based on `NG_ORG` when unset.
+
+One config entry = one org, because the API key is org-specific. To work against multiple orgs, add multiple entries (e.g. `pitcher-dev`, `pitcher-prod`) with different env blocks; do not try to pass org per tool call.
+
+### Host config example (Claude Desktop / `.mcp.json`)
+
+```jsonc
+"pitcher": {
+  "command": "npx",
+  "args": ["-y", "@pitcher/cli-scripts", "mcp"],
+  "env": { "NG_API_KEY": "<key>", "NG_ORG": "dev" }
+}
+```
+
+### Tool annotations
+
+- 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.
+
+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:
 
 ```bash

package/dist/index.js

@@ -25,6 +25,7 @@ import { createGroupsCommand } from './src/commands/groups.js';
 import { createRolesCommand } from './src/commands/roles.js';
 import { createMetadataTemplateCommand } from './src/commands/metadataTemplate.js';
 import { createDsrCommand } from './src/commands/dsr.js';
+import { createMcpCommand } from './src/commands/mcp.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
@@ -57,4 +58,5 @@ program.addCommand(createMetadataTemplateCommand());
 program.addCommand(createDsrCommand());
 program.addCommand(createOrgCommand());
 program.addCommand(createAnalyticsCommand());
+program.addCommand(createMcpCommand());
 program.parseAsync(process.argv);

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createMcpCommand(): Command;

package/dist/src/commands/mcp.js

@@ -0,0 +1,18 @@
+import { Command } from 'commander';
+import { runMcpServe } from '../mcp/serve.js';
+import { isCliError } from '../core/errors.js';
+export function createMcpCommand() {
+    return new Command('mcp')
+        .description('Run the Pitcher MCP server over stdio (reads NG_API_KEY, NG_ORG/NG_URL, NG_ENV from env)')
+        .action(async () => {
+        try {
+            await runMcpServe();
+        }
+        catch (e) {
+            const message = isCliError(e) ? e.message : e instanceof Error ? e.message : String(e);
+            console.error(`[pitcher-mcp] failed to start: ${message}`);
+            process.exitCode = isCliError(e) ? e.exitCode : 1;
+            return;
+        }
+    });
+}

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

@@ -0,0 +1,7 @@
+export interface McpEnv {
+    apiKey: string;
+    org?: string;
+    url?: string;
+    prod: boolean;
+}
+export declare function resolveMcpEnv(env?: NodeJS.ProcessEnv): McpEnv;

package/dist/src/mcp/env.js

@@ -0,0 +1,13 @@
+import { createCliError } from '../core/errors.js';
+export function resolveMcpEnv(env = process.env) {
+    const apiKey = env.NG_API_KEY?.trim();
+    if (!apiKey) {
+        throw createCliError('AUTH', 'NG_API_KEY is required to run the MCP server (set it in the host config env).');
+    }
+    const org = env.NG_ORG?.trim() || 'dev';
+    const url = env.NG_URL?.trim() || undefined;
+    const ngEnv = env.NG_ENV?.trim();
+    const isDevHost = url ? /\/\/dev\.my\.pitcher\.com(\/|$)/.test(url) : org === 'dev';
+    const prod = ngEnv === 'prod' ? true : ngEnv === 'test' ? false : !isDevHost;
+    return { apiKey, org, url, prod };
+}

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

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

package/dist/src/mcp/registry.js

@@ -0,0 +1,46 @@
+import { analyticsTools } from './tools/analytics.js';
+import { announcementsTools } from './tools/announcements.js';
+import { canvasesTools } from './tools/canvases.js';
+import { devSyncTools } from './tools/devSync.js';
+import { dsrTools } from './tools/dsr.js';
+import { dsrLandingTools } from './tools/dsrLanding.js';
+import { emailTemplateTools } from './tools/emailTemplate.js';
+import { filesTools } from './tools/files.js';
+import { foldersTools } from './tools/folders.js';
+import { groupsTools } from './tools/groups.js';
+import { instancesTools } from './tools/instances.js';
+import { invitationsTools } from './tools/invitations.js';
+import { membershipsTools } from './tools/memberships.js';
+import { metadataTemplateTools } from './tools/metadataTemplate.js';
+import { orgTools } from './tools/org.js';
+import { publishAppTools } from './tools/publishApp.js';
+import { rolesTools } from './tools/roles.js';
+import { searchTools } from './tools/search.js';
+import { sharedLinksTools } from './tools/sharedLinks.js';
+import { tagsTools } from './tools/tags.js';
+import { themesTools } from './tools/themes.js';
+import { usersTools } from './tools/users.js';
+export const allTools = [
+    ...canvasesTools,
+    ...filesTools,
+    ...foldersTools,
+    ...searchTools,
+    ...instancesTools,
+    ...sharedLinksTools,
+    ...tagsTools,
+    ...announcementsTools,
+    ...dsrLandingTools,
+    ...dsrTools,
+    ...emailTemplateTools,
+    ...themesTools,
+    ...usersTools,
+    ...invitationsTools,
+    ...rolesTools,
+    ...orgTools,
+    ...analyticsTools,
+    ...membershipsTools,
+    ...groupsTools,
+    ...metadataTemplateTools,
+    ...devSyncTools,
+    ...publishAppTools,
+];

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

@@ -0,0 +1,13 @@
+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 function toErrorResult(code: string, message: string): CallToolResultShape;
+export declare function envelopeToToolResult(env: Envelope<unknown>): CallToolResultShape;

package/dist/src/mcp/result.js

@@ -0,0 +1,20 @@
+function isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+export function toErrorResult(code, message) {
+    return { content: [{ type: 'text', text: `${code}: ${message}` }], isError: true };
+}
+export function envelopeToToolResult(env) {
+    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;
+}

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

@@ -0,0 +1 @@
+export declare function runMcpServe(env?: NodeJS.ProcessEnv): Promise<void>;

package/dist/src/mcp/serve.js

@@ -0,0 +1,13 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { resolveMcpEnv } from './env.js';
+import { buildServer } from './server.js';
+import { allTools } from './registry.js';
+// Resolves auth/env, builds the server, connects stdio. Never writes to stdout except protocol frames.
+export async function runMcpServe(env = process.env) {
+    const mcpEnv = resolveMcpEnv(env);
+    const server = buildServer(mcpEnv);
+    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)' : ''}`);
+}

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

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpEnv } from './env.js';
+export declare function buildServer(env: McpEnv): McpServer;

package/dist/src/mcp/server.js

@@ -0,0 +1,41 @@
+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 { envelopeToToolResult, toErrorResult } from './result.js';
+import { isCliError } from '../core/errors.js';
+const version = (() => {
+    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';
+    }
+})();
+export function buildServer(env) {
+    const server = new McpServer({ name: 'pitcher', version });
+    for (const tool of allTools) {
+        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);
+            }
+        });
+    }
+    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,30 @@
+import { z } from 'zod';
+import { runCanvasesList, runCanvasesGet } from '../../commands/canvases.js';
+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.',
+        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)'),
+            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,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_canvases_get',
+        title: 'Get a canvas',
+        description: 'Retrieve a single canvas by its ID.',
+        inputShape: { id: z.string().describe('Canvas ID') },
+        run: 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,45 @@
+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)'),
+            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'),
+            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,47 @@
+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)'),
+            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[];

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { runFilesList, runFilesGet, runFilesCreate, runFilesUpdate } from '../../commands/files.js';
+export const filesTools = [
+    {
+        name: 'pitcher_files_list',
+        title: 'List files',
+        description: 'List content files in an instance. Filter by tags or specific IDs.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            idIn: z.string().optional().describe('Comma-separated file IDs'),
+            tags: z.string().optional().describe('Comma-separated tags'),
+            page: z.number().int().optional(),
+            pageSize: z.number().int().optional(),
+        },
+        run: runFilesList,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_files_get',
+        title: 'Get a file',
+        description: 'Retrieve a single file by its ID.',
+        inputShape: { id: z.string().describe('File ID') },
+        run: runFilesGet,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_files_create',
+        title: 'Create a file',
+        description: 'Create a content file in an instance, from a local file path (on the server host) or a source URL. Additive.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            name: z.string().optional().describe('File name'),
+            folderId: z.string().optional().describe('Destination folder'),
+            filePath: z.string().optional().describe('Local file path to upload (on the MCP server host)'),
+            sourceUrl: z.string().optional().describe('Link/WEB file source URL'),
+            accessType: z.enum(['public', 'restricted', 'personal']).optional(),
+            tags: z.string().optional().describe('Comma-separated tags'),
+            metadata: z.string().optional().describe('metadata JSON object as a string'),
+            appMetadata: z.string().optional().describe('app_metadata JSON object as a string'),
+        },
+        run: runFilesCreate,
+        readOnly: false,
+        write: true,
+    },
+    {
+        name: 'pitcher_files_update',
+        title: 'Update a file',
+        description: 'Update a file by ID (name, folder, access, tags, metadata). filePath or sourceUrl replaces/overwrites the file binary; metadata is deep-merged.',
+        inputShape: {
+            id: z.string().describe('File ID'),
+            instanceId: z.string().optional().describe('Instance ID (required only with filePath)'),
+            name: z.string().optional(),
+            folderId: z.string().optional(),
+            filePath: z.string().optional().describe('Local file path to replace the binary (on the MCP server host)'),
+            sourceUrl: z.string().optional(),
+            accessType: z.enum(['public', 'restricted', 'personal']).optional(),
+            tags: z.string().optional().describe('Comma-separated tags'),
+            metadata: z.string().optional().describe('metadata JSON object as a string (deep-merged)'),
+            appMetadata: z.string().optional().describe('app_metadata JSON object as a string (deep-merged)'),
+        },
+        run: runFilesUpdate,
+        readOnly: false,
+        write: true,
+    },
+];

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

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