@pitcher/cli-scripts 2.8.0 → 2.10.0

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[];

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

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { runFoldersList, runFoldersGet, runFoldersCreate, runFoldersUpdate } from '../../commands/folders.js';
+export const foldersTools = [
+    {
+        name: 'pitcher_folders_list',
+        title: 'List folders',
+        description: 'List folders in an instance. Use to discover folder IDs before creating content or browsing structure.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            page: z.number().int().optional(),
+            pageSize: z.number().int().optional().describe('Page size (max 500)'),
+        },
+        run: runFoldersList,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_folders_get',
+        title: 'Get a folder',
+        description: 'Retrieve a single folder by its ID, or the instance root folder via root + instanceId.',
+        inputShape: {
+            id: z.string().optional().describe('Folder ID (omit and set root=true for the instance root)'),
+            root: z.boolean().optional().describe('Fetch the instance root folder'),
+            instanceId: z.string().optional().describe('Instance ID (required with root)'),
+        },
+        run: runFoldersGet,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_folders_create',
+        title: 'Create a folder',
+        description: 'Create a folder under a parent folder in an instance. Additive.',
+        inputShape: {
+            name: z.string().describe('Folder name (required)'),
+            parentFolderId: z.string().describe('Parent folder ID (required)'),
+            accessType: z.enum(['public', 'restricted', 'personal']).optional(),
+            rules: z.string().optional().describe('Smart-folder rules JSON array as a string'),
+        },
+        run: runFoldersCreate,
+        readOnly: false,
+        write: true,
+    },
+    {
+        name: 'pitcher_folders_update',
+        title: 'Update a folder',
+        description: 'Update an existing folder by ID (name, access type, or smart-folder rules; rules replace existing).',
+        inputShape: {
+            id: z.string().describe('Folder ID'),
+            name: z.string().optional().describe('Folder name'),
+            accessType: z.enum(['public', 'restricted', 'personal']).optional(),
+            rules: z.string().optional().describe('Smart-folder rules JSON array as a string (replaces existing)'),
+        },
+        run: runFoldersUpdate,
+        readOnly: false,
+        write: true,
+    },
+];

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

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

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

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { runGroupsList, runGroupsGet, runGroupsCreate, runGroupsAddUser, runGroupsListUsers, } from '../../commands/groups.js';
+export const groupsTools = [
+    {
+        name: 'pitcher_groups_list',
+        title: 'List content-distribution groups',
+        description: 'List content-distribution groups. Filter by instance.',
+        inputShape: {
+            instanceId: z.string().optional().describe('Filter by instance'),
+            page: z.number().int().optional().describe('Page number'),
+            pageSize: z.number().int().optional().describe('Page size (max 500)'),
+        },
+        run: runGroupsList,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_groups_get',
+        title: 'Get a group',
+        description: 'Retrieve a single content-distribution group by its ID.',
+        inputShape: { id: z.string().describe('Group ID') },
+        run: runGroupsGet,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_groups_create',
+        title: 'Create a group',
+        description: 'Create a content-distribution group in an instance. Additive.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            name: z.string().describe('Group name (required)'),
+        },
+        run: runGroupsCreate,
+        readOnly: false,
+        write: true,
+    },
+    {
+        name: 'pitcher_groups_add_user',
+        title: 'Add a user to a group',
+        description: 'Add a user to a content-distribution group. Rejected on auto-login-managed groups.',
+        inputShape: {
+            groupId: z.string().describe('Group ID (required)'),
+            userId: z.string().describe('User ID (integer, required)'),
+        },
+        run: runGroupsAddUser,
+        readOnly: false,
+        write: true,
+    },
+    {
+        name: 'pitcher_groups_list_users',
+        title: "List a group's members",
+        description: "List a content-distribution group's members.",
+        inputShape: {
+            groupId: z.string().describe('Group whose members to list (required)'),
+            page: z.number().int().optional().describe('Page number'),
+            pageSize: z.number().int().optional().describe('Page size (max 500)'),
+        },
+        run: runGroupsListUsers,
+        readOnly: true,
+    },
+];

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

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

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

@@ -0,0 +1,82 @@
+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',
+        title: 'List instances',
+        description: 'Discover Pitcher instances in the org. Use to resolve instance names to instance IDs.' +
+            ' Output may include raw instance settings/metadata (potentially integration credentials) - treat as sensitive.',
+        inputShape: {
+            region: z.string().optional().describe('Filter by region'),
+            storageRegion: z.string().optional().describe('Filter by storage region'),
+            environment: z.string().optional().describe('Filter by environment'),
+            page: z.number().int().optional(),
+            pageSize: z.number().int().optional().describe('Page size (max 500)'),
+        },
+        run: runInstancesList,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_instances_info',
+        title: 'Get an instance',
+        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: runInstancesInfoWithTerminology,
+        wraps: runInstancesInfo,
+        readOnly: true,
+    },
+];

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

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

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { runInvitationsList, runInvitationsGet } from '../../commands/invitations.js';
+export const invitationsTools = [
+    {
+        name: 'pitcher_invitations_list',
+        title: 'List invitations',
+        description: 'List pending user invitations in the org.',
+        inputShape: {
+            page: z.number().int().optional().describe('Page number'),
+            pageSize: z.number().int().optional().describe('Page size (max 500)'),
+        },
+        run: runInvitationsList,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_invitations_get',
+        title: 'Get an invitation',
+        description: 'Retrieve a single pending invitation by ID.',
+        inputShape: { id: z.string().describe('Invitation ID') },
+        run: runInvitationsGet,
+        readOnly: true,
+    },
+];

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

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

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

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { runMembershipsList, runMembershipsAdd, runMembershipsSetRole } from '../../commands/memberships.js';
+export const membershipsTools = [
+    {
+        name: 'pitcher_memberships_list',
+        title: 'List instance memberships',
+        description: 'List instance memberships. Filter by instance or user to discover membership IDs before set-role.',
+        inputShape: {
+            instanceId: z.string().optional().describe('Filter by instance'),
+            userId: z.string().optional().describe('Filter by user (integer id)'),
+            page: z.number().int().optional().describe('Page number'),
+            pageSize: z.number().int().optional().describe('Page size (max 500)'),
+        },
+        run: runMembershipsList,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_memberships_add',
+        title: 'Add a member',
+        description: "Add a user to an instance as 'member' (role is always 'member' — this endpoint never accepts a " +
+            "caller-supplied role). Use pitcher_memberships_set_role to change the role afterward.",
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            userId: z.string().describe('User ID (integer, required)'),
+        },
+        run: runMembershipsAdd,
+        readOnly: false,
+        write: true,
+    },
+    {
+        name: 'pitcher_memberships_set_role',
+        title: 'Set a membership role',
+        description: "Change a membership's role via the validating next-core endpoint. Requires an org-admin key. " +
+            "--role is the SHORT role name (e.g. 'editor') from pitcher_roles_list, not a prefixed key.",
+        inputShape: {
+            membershipId: z.string().describe('Membership row ID (integer, required)'),
+            role: z.string().describe('Short role name, e.g. editor (required)'),
+            scope: z
+                .enum(['instance', 'organization'])
+                .optional()
+                .describe('Scope of the role assignment (default instance)'),
+        },
+        run: runMembershipsSetRole,
+        readOnly: false,
+        write: true,
+    },
+];

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

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

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { runMetadataTemplateList, runMetadataTemplateGet, runMetadataTemplateUpsert, } from '../../commands/metadataTemplate.js';
+export const metadataTemplateTools = [
+    {
+        name: 'pitcher_metadata_template_list',
+        title: 'List metadata templates',
+        description: "List an instance's metadata-field schema(s) (metadata templates).",
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            page: z.number().int().optional().describe('Page number'),
+            pageSize: z.number().int().optional().describe('Page size (max 500)'),
+        },
+        run: runMetadataTemplateList,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_metadata_template_get',
+        title: 'Get a metadata template',
+        description: 'Retrieve a single metadata template by its ID (ULID).',
+        inputShape: { id: z.string().describe('Metadata template ID (ULID)') },
+        run: runMetadataTemplateGet,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_metadata_template_upsert',
+        title: 'Upsert a metadata template',
+        description: "Upsert an instance's metadata-field schema. Merges the incoming sections by section 'label' — a " +
+            'section whose label matches an existing one is replaced, other sections are preserved. Cannot remove ' +
+            'a section or field. Pass exactly one of sections or sectionsFile. Requires an instance- or org-admin key.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            sections: z.string().optional().describe('Sections JSON array (inline)'),
+            sectionsFile: z
+                .string()
+                .optional()
+                .describe('Path to a JSON file (on the MCP server host) with the sections array'),
+        },
+        run: runMetadataTemplateUpsert,
+        readOnly: false,
+        write: true,
+    },
+];

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

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

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

@@ -0,0 +1,12 @@
+import { runOrgGet } from '../../commands/org.js';
+export const orgTools = [
+    {
+        name: 'pitcher_org_get',
+        title: 'Get the organization',
+        description: 'Retrieve the organization the API key belongs to. Response may include raw settings/metadata ' +
+            '(potentially integration credentials) — treat output as sensitive.',
+        inputShape: {},
+        run: runOrgGet,
+        readOnly: true,
+    },
+];

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

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

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

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { runPublishApp } from '../../commands/publishApp.js';
+// Narrow individual injected/validated values (the MCP zod schema already guarantees the runtime
+// type) instead of casting the whole opts blob — same approach as the devSync wrappers.
+const asString = (v) => (typeof v === 'string' ? v : undefined);
+const asBool = (v) => (typeof v === 'boolean' ? v : undefined);
+export const publishAppTools = [
+    {
+        name: 'pitcher_publish_app',
+        title: 'Publish an app release',
+        description: 'Zip a local app folder (on the MCP server host) and publish it as a new app release to the org, ' +
+            'optionally installing it to specific instances or all instances of an environment afterward. ' +
+            'Consequential: this creates a live, org-visible app release — use dryRun to preview first. ' +
+            'Re-publishing an already-existing version is a no-op (returns ok with a warning), not a failure. ' +
+            'Publish targets the org resolved from NG_ORG; the injected NG_URL is not used as the publish endpoint.',
+        inputShape: {
+            folder: z.string().optional().describe('Local folder to zip and publish (defaults to the MCP server cwd)'),
+            incrementVersion: z.boolean().optional().describe('Bump the version in app.json before publishing'),
+            dryRun: z.boolean().optional().describe('Preview the publish (version, target) without publishing anything'),
+            installTo: z.string().optional().describe('Comma-separated instance IDs to install the app to after publishing'),
+            installToEnvName: z.string().optional().describe('Environment name (e.g. "test") to install the app to after publishing'),
+        },
+        // runPublishApp overloads `url` as BOTH origin and publish endpoint; the server injects NG_URL into
+        // every tool, so forward only apiKey + org (never url) plus this tool's own inputs.
+        run: (opts) => runPublishApp({
+            folder: asString(opts.folder),
+            incrementVersion: asBool(opts.incrementVersion),
+            dryRun: asBool(opts.dryRun),
+            installTo: asString(opts.installTo),
+            installToEnvName: asString(opts.installToEnvName),
+            apiKey: opts.apiKey,
+            org: opts.org,
+        }),
+        wraps: runPublishApp,
+        readOnly: false,
+        write: true,
+        alwaysDestructive: true,
+    },
+];

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

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

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { runRolesList } from '../../commands/roles.js';
+export const rolesTools = [
+    {
+        name: 'pitcher_roles_list',
+        title: 'List roles',
+        description: 'List the org role set (system + custom roles) — use to discover valid short role names ' +
+            'before setting a membership role. Needs an org-admin key.',
+        inputShape: {
+            scope: z.enum(['instance', 'organization']).optional().describe('Filter by scope'),
+        },
+        run: runRolesList,
+        readOnly: true,
+    },
+];

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

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

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { runSearch } from '../../commands/search.js';
+export const searchTools = [
+    {
+        name: 'pitcher_search',
+        title: 'Search content',
+        description: 'Cross-type ranked search across an instance (files, canvases, users, apps). Use to find content by keyword when the ID is unknown.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            query: z.string().describe('Search query (required)'),
+            includeExpired: z.boolean().optional().describe('Include expired content'),
+        },
+        run: runSearch,
+        readOnly: true,
+    },
+];

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

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

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

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { runSharedLinksCreate, runSharedLinksGet } from '../../commands/sharedLinks.js';
+export const sharedLinksTools = [
+    {
+        name: 'pitcher_shared_links_create',
+        title: 'Create a shared link',
+        description: 'Create a share link (short_url) for a canvas or a file. Pass exactly one of canvasId or fileId. Additive.',
+        inputShape: {
+            canvasId: z.string().optional().describe('Canvas to share (exactly one of canvasId/fileId is required)'),
+            fileId: z.string().optional().describe('File to share (exactly one of canvasId/fileId is required)'),
+        },
+        run: runSharedLinksCreate,
+        readOnly: false,
+        write: true,
+    },
+    {
+        name: 'pitcher_shared_links_get',
+        title: 'Get a shared link',
+        description: 'Retrieve the existing share link for a canvas or a file. Pass exactly one of canvasId or fileId.',
+        inputShape: {
+            canvasId: z.string().optional().describe('Canvas whose link to fetch (exactly one of canvasId/fileId is required)'),
+            fileId: z.string().optional().describe('File whose link to fetch (exactly one of canvasId/fileId is required)'),
+        },
+        run: runSharedLinksGet,
+        readOnly: true,
+    },
+];

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

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

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { runTagsList } from '../../commands/tags.js';
+export const tagsTools = [
+    {
+        name: 'pitcher_tags_list',
+        title: 'List tags',
+        description: 'List tags in an instance matching a search term (at least 3 characters). Use to discover tag values before filtering files/canvases.',
+        inputShape: {
+            instanceId: z.string().describe('Instance ID (required)'),
+            search: z.string().min(3).describe('Search term (required, at least 3 characters)'),
+            type: z.enum(['files', 'canvases']).optional(),
+            canvasType: z.string().optional().describe('Canvas type filter'),
+            includeHidden: z.boolean().optional().describe('Include hidden tags'),
+            page: z.number().int().optional(),
+            pageSize: z.number().int().optional().describe('Page size (max 500)'),
+        },
+        run: runTagsList,
+        readOnly: true,
+    },
+];

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

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

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

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { runThemesList, runThemesGet } from '../../commands/themes.js';
+export const themesTools = [
+    {
+        name: 'pitcher_themes_list',
+        title: 'List themes',
+        description: 'List canvas/branding themes (colors, fonts, assets) in the org. Omit instanceId to see all ' +
+            'org-level and instance themes; set it to narrow to themes bound to that instance.',
+        inputShape: {
+            instanceId: z
+                .string()
+                .optional()
+                .describe('Filter to themes bound to this instance (excludes org-level themes)'),
+            withUsage: z.boolean().optional().describe('Include a per-theme count of canvases using it'),
+            withCanvasIds: z.boolean().optional().describe('Include the canvas ids using each theme'),
+        },
+        run: runThemesList,
+        readOnly: true,
+    },
+    {
+        name: 'pitcher_themes_get',
+        title: 'Get a theme',
+        description: 'Retrieve a single theme by its ID.',
+        inputShape: { id: z.string().describe('Theme ID') },
+        run: runThemesGet,
+        readOnly: true,
+    },
+];

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

@@ -0,0 +1,15 @@
+import type { z } from 'zod';
+import type { Envelope } from '../../core/envelope.js';
+import type { CommonOpts } from '../../core/http.js';
+export type InjectedAuth = Pick<CommonOpts, 'apiKey' | 'org' | 'url'>;
+export interface ToolDescriptor {
+    name: string;
+    title: string;
+    description: string;
+    inputShape: z.ZodRawShape;
+    run: (opts: Record<string, unknown> & InjectedAuth, deps?: any) => Promise<Envelope<unknown>>;
+    wraps?: (...a: any[]) => unknown;
+    readOnly: boolean;
+    write?: boolean;
+    alwaysDestructive?: boolean;
+}

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

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

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

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