@uniformdev/uniform-mcp 20.14.2-alpha.35

package/LICENSE.txt

@@ -0,0 +1,2 @@
+© 2024 Uniform Systems, Inc. All Rights Reserved.
+See details of Uniform Systems, Inc. Master Subscription Agreement here: https://uniform.dev/eula

package/README.md

@@ -0,0 +1,49 @@
+## Uniform MCP Server
+
+A stdio-transport MCP server which allows you to manipulate Uniform entities.
+
+Part of the [Uniform Platform](https://uniform.app). See our [documentation](https://docs.uniform.app) for more details.
+
+
+### Setup
+
+#### Uniform Context
+
+Copy `references/*.mdc` to your project and set it to be referenced as you wish.
+For Cursor, this belongs in `.cursor/rules/*.mdc`.
+
+#### Register MCP server
+
+* Add the following to `.cursor/mcp.json` (for other editors, this should be easily convertible)
+
+```
+{
+  "mcpServers": {
+    "Uniform": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@uniformdev/uniform-mcp"],
+      "env": {
+        "UNIFORM_API_KEY": "your-api-key",
+        "UNIFORM_PROJECT_ID": "your-project-id",
+        // optional, only needed if your host is not uniform.app (e.g. EU users)
+        "UNIFORM_API_HOST": "https://uniform.app",
+      }
+    }
+  }
+}
+
+```
+
+* Enable the MCP server if necessary.
+
+Note: if you are developing against this mcp server, you must use `node` with args `../path/to/this-package-source/dist/index.js` - npx does not support local packages. If your Uniform API host is self-signed, `NODE_TLS_REJECT_UNAUTHORIZED: 0` env var works, but do not use in production.
+
+## Notable Limitations
+
+Pattern editing supports a limited subset of patterns. Specifically:
+
+- Locale support is rudimentary (cannot enable or disable locales, but can change existing localized param values)
+- Conditional values are not supported
+- Inserting other nested patterns is not supported
+- Editing overrides is not supported

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,618 @@
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/componentPattern/componentPatternAction.ts
+import {
+  CANVAS_DRAFT_STATE,
+  CanvasClient,
+  walkNodeTree
+} from "@uniformdev/canvas";
+import { produce } from "immer";
+import { z as z3 } from "zod";
+
+// src/env.ts
+var apiKey = process.env.UNIFORM_API_KEY;
+var projectId = process.env.UNIFORM_PROJECT_ID;
+var apiHost = process.env.UNIFORM_API_HOST ?? "https://uniform.app";
+if (!apiKey) {
+  throw new Error("UNIFORM_API_KEY is not set");
+}
+if (!projectId) {
+  throw new Error("UNIFORM_PROJECT_ID is not set");
+}
+var env = {
+  apiHost,
+  apiKey,
+  projectId,
+  baseWebUrl: `${apiHost}/projects/${projectId}`
+};
+
+// src/tools/componentPattern/util.ts
+import { z as z2 } from "zod";
+
+// src/properties.ts
+import { z } from "zod";
+var propertyDefinitionSchema = z.object({
+  name: z.string().describe('Title-cased display name. Ex: "Headline"'),
+  id: z.string().describe("The public ID. Must be unique within the current entity fields/parameters."),
+  type: z.enum([
+    "text",
+    "richText",
+    "link",
+    "asset",
+    "number",
+    "date",
+    "dateTime",
+    "checkbox",
+    "reference",
+    "select"
+  ]),
+  guidance: z.string().describe(
+    'Describe what kind of content should be populated, for a LLM to use as a guide. 1-2 sentences max. Ex: "Meta tags based on the content", "2-3 word headline"'
+  ),
+  localizable: z.boolean().describe("Whether values are stored as locale-specific"),
+  typeConfig: z.object({
+    allowedTypes: z.array(z.enum(["image", "video", "audio", "other"])).optional().describe("The types of asset allowed. ONLY applies when type=asset, omit for other types"),
+    options: z.array(
+      z.object({
+        text: z.string().describe("The text to display to the author"),
+        value: z.string().describe("The value to store for the option")
+      })
+    ).optional().describe(
+      "The author-selectable options for the select property. ONLY applies when type=select, omit for other types"
+    ),
+    required: z.boolean()
+  }).optional()
+});
+
+// src/tools/componentPattern/util.ts
+var aiContentTypeDefinitionSchema = z2.object({
+  name: z2.string().describe('Title-cased display name of the component. Ex: "Hero"'),
+  id: z2.string().describe(
+    "Public ID of the content type, the camelCase version of name, using only alphanumeric characters"
+  ),
+  description: z2.string().describe("Describe the purpose of the content type in 1-2 sentences."),
+  fields: z2.array(propertyDefinitionSchema).describe("The fields of the content type. The key is the publicId of the field.").optional()
+});
+function linkToComponentPattern(id) {
+  return `${env.baseWebUrl}/dashboards/canvas/edit/${id}`;
+}
+
+// src/tools/componentPattern/componentPatternAction.ts
+var componentPatternActionSchema = {
+  action: z3.enum(["create", "update", "delete"]).describe("The action to perform"),
+  patternUuid: z3.string().uuid().describe("UUID of the pattern instance to create, update, or delete"),
+  name: z3.string().describe(
+    "Name of the pattern. If the name does not need to be changed, omit this field. Always include for creates."
+  ).optional(),
+  patternType: z3.string().describe(
+    "Component definition type of the pattern. Must be registered with Uniform. Always include for creates. Omit otherwise."
+  ).optional(),
+  newComponentsInSlots: z3.array(
+    z3.object({
+      parentComponentId: z3.string().describe("ID of the component the slot belongs to"),
+      slotName: z3.string().describe("Public ID of the target slot"),
+      slotIndex: z3.number().describe("Index to insert the new component at. Omit for append.").optional(),
+      componentType: z3.string().describe(
+        "Public ID of the component type to insert. Component type must be registered with Uniform."
+      ),
+      newComponentInstanceUuid: z3.string().uuid().describe("ID of the new component to create - generate a random unique UUID")
+    })
+  ).describe(
+    "New components to insert in slots. Omit for delete. These are performed before deleting components or parameter updates."
+  ).optional(),
+  deletedComponentsInSlots: z3.array(z3.string().describe("Component ID to remove. Cannot be the pattern root component.")).describe(
+    "Components to delete from slots during an update. Omit for create or delete, or if nothing needs deleting. These are performed before parameter updates."
+  ).optional(),
+  parameterUpdates: z3.array(
+    z3.object({
+      componentId: z3.string().describe("ID of the component the parameter belongs to"),
+      parameterId: z3.string().describe(
+        "Public ID of the parameter to update. Must be defined in the component type of the parent componentId"
+      ),
+      parameterType: z3.string().describe("The type of the parameterId as defined on the component definition"),
+      locale: z3.string().describe("Locale of the parameter value. Omit for non-localized values.").optional(),
+      value: z3.any().describe("New value for the parameter. Use null to remove an existing value.")
+    }).describe("A value change to a parameter. Omit unchanged parameters.")
+  ).describe("Updates to the parameters of the pattern. Omit for delete.").optional()
+};
+function registerComponentPatternAction(server2) {
+  server2.tool(
+    "componentPatternAction",
+    "Creates, updates, or deletes a Uniform Component Pattern or Composition Pattern",
+    componentPatternActionSchema,
+    async ({
+      action,
+      patternUuid,
+      name,
+      patternType,
+      deletedComponentsInSlots,
+      newComponentsInSlots,
+      parameterUpdates
+    }) => {
+      const canvasClient = new CanvasClient(env);
+      if (action === "create") {
+        if (!name) {
+          throw new Error("Name is required for create");
+        }
+        if (!patternType) {
+          throw new Error("Pattern type is required for create");
+        }
+        const coreComposition = {
+          projectId: env.projectId,
+          state: CANVAS_DRAFT_STATE,
+          pattern: true,
+          composition: {
+            _id: patternUuid,
+            _name: name,
+            type: patternType
+          }
+        };
+        const composition = applyCompositionPatches(
+          coreComposition,
+          deletedComponentsInSlots ?? [],
+          newComponentsInSlots ?? [],
+          parameterUpdates ?? [],
+          name
+        );
+        await canvasClient.updateComposition(composition);
+      }
+      if (action === "update") {
+        const existingComposition = await canvasClient.getCompositionById({
+          compositionId: patternUuid,
+          state: CANVAS_DRAFT_STATE,
+          skipDataResolution: true,
+          skipPatternResolution: true,
+          withComponentIDs: true,
+          skipOverridesResolution: true
+        });
+        const composition = applyCompositionPatches(
+          existingComposition,
+          deletedComponentsInSlots ?? [],
+          newComponentsInSlots ?? [],
+          parameterUpdates ?? [],
+          name
+        );
+        await canvasClient.updateComposition(composition);
+      }
+      if (action === "delete") {
+        await canvasClient.removeComposition({ compositionId: patternUuid });
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true, editUrl: linkToComponentPattern(patternUuid) }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+function applyCompositionPatches(existingComposition, deletedComponentsInSlots, newComponentsInSlots, parameterUpdates, nameUpdate) {
+  return produce(existingComposition, (draft) => {
+    if (nameUpdate) {
+      draft.composition._name = nameUpdate;
+    }
+    const remainingInsertions = newComponentsInSlots.reduce(
+      (acc, newComponent) => {
+        acc[newComponent.newComponentInstanceUuid] = newComponent;
+        return acc;
+      },
+      {}
+    );
+    for (const newComponent of newComponentsInSlots ?? []) {
+      walkNodeTree(draft.composition, ({ node, type }) => {
+        if (type !== "component" || node._id !== newComponent.parentComponentId) {
+          return;
+        }
+        node.slots ??= {};
+        node.slots[newComponent.slotName] ??= [];
+        node.slots[newComponent.slotName].splice(
+          newComponent.slotIndex ?? node.slots[newComponent.slotName].length,
+          0,
+          {
+            _id: newComponent.newComponentInstanceUuid,
+            type: newComponent.componentType
+          }
+        );
+        delete remainingInsertions[newComponent.newComponentInstanceUuid];
+      });
+    }
+    if (Object.keys(remainingInsertions).length > 0) {
+      throw new Error(
+        `New components with invalid parent component IDs were not inserted: ${Object.keys(remainingInsertions).join(", ")}`
+      );
+    }
+    const remainingDeletions = deletedComponentsInSlots.reduce(
+      (acc, deletedComponent) => {
+        acc[deletedComponent] = deletedComponent;
+        return acc;
+      },
+      {}
+    );
+    for (const deletedComponent of deletedComponentsInSlots ?? []) {
+      walkNodeTree(draft.composition, ({ node, actions }) => {
+        if (node._id !== deletedComponent) {
+          return;
+        }
+        actions.remove();
+        delete remainingDeletions[deletedComponent];
+      });
+    }
+    if (Object.keys(remainingDeletions).length > 0) {
+      throw new Error(
+        `Components with invalid IDs were not deleted: ${Object.keys(remainingDeletions).join(", ")}`
+      );
+    }
+    const remainingParameterUpdates = parameterUpdates.reduce(
+      (acc, parameterUpdate) => {
+        acc[parameterUpdate.componentId + parameterUpdate.parameterId] = parameterUpdate;
+        return acc;
+      },
+      {}
+    );
+    for (const parameterUpdate of parameterUpdates ?? []) {
+      walkNodeTree(draft.composition, ({ node, type }) => {
+        if (node._id !== parameterUpdate.componentId) {
+          return;
+        }
+        let properties;
+        if (type === "component") {
+          node.parameters ??= {};
+          properties = node.parameters;
+        } else {
+          node.fields ??= {};
+          properties = node.fields;
+        }
+        properties[parameterUpdate.parameterId] ??= { type: parameterUpdate.parameterType };
+        const property = properties[parameterUpdate.parameterId];
+        if (parameterUpdate.locale) {
+          property.locales ??= {};
+          property.locales[parameterUpdate.locale] = parameterUpdate.value;
+        } else {
+          property.value = parameterUpdate.value;
+        }
+        delete remainingParameterUpdates[parameterUpdate.componentId + parameterUpdate.parameterId];
+      });
+    }
+    if (Object.keys(remainingParameterUpdates).length > 0) {
+      throw new Error(
+        `Parameter updates with invalid component IDs were not applied: ${Object.keys(remainingParameterUpdates).join(", ")}`
+      );
+    }
+  });
+}
+
+// src/tools/componentPattern/componentPatternList.ts
+import { CANVAS_DRAFT_STATE as CANVAS_DRAFT_STATE2, CanvasClient as CanvasClient2 } from "@uniformdev/canvas";
+import { z as z4 } from "zod";
+var componentInstanceListOptions = {
+  instanceType: z4.enum(["componentPattern", "compositionPattern"])
+};
+var componentInstanceGetOptions = {
+  id: z4.string()
+};
+function registerComponentPatternList(server2) {
+  server2.tool(
+    "componentPatternList",
+    "Lists available Uniform component patterns or composition patterns",
+    componentInstanceListOptions,
+    async ({ instanceType }) => {
+      const canvasClient = new CanvasClient2(env);
+      const components = await canvasClient.getCompositionList({
+        patternType: instanceType === "componentPattern" ? "component" : "composition",
+        pattern: true,
+        resolveData: false,
+        withComponentIDs: true,
+        skipOverridesResolution: true,
+        limit: 100,
+        skipPatternResolution: true,
+        state: CANVAS_DRAFT_STATE2
+      });
+      const componentInstances = components.compositions.map(
+        (composition) => ({
+          id: composition.composition._id,
+          name: composition.composition._name,
+          componentType: composition.composition.type,
+          editUrl: linkToComponentPattern(composition.composition._id)
+        })
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(componentInstances, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "componentPatternGet",
+    "Gets the full contents of a Uniform component pattern or composition pattern",
+    componentInstanceGetOptions,
+    async ({ id }) => {
+      const canvasClient = new CanvasClient2(env);
+      const pattern = await canvasClient.getCompositionById({
+        skipDataResolution: true,
+        withComponentIDs: true,
+        skipOverridesResolution: true,
+        skipPatternResolution: true,
+        compositionId: id,
+        state: CANVAS_DRAFT_STATE2
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(pattern, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/components/componentAction.ts
+import { CanvasClient as CanvasClient3 } from "@uniformdev/canvas";
+import { z as z7 } from "zod";
+
+// src/patches/applyPatch.ts
+import jsonPatch from "fast-json-patch";
+function applyJsonPatch(document, patch) {
+  return jsonPatch.applyPatch(document, patch).newDocument;
+}
+
+// src/patches/types.ts
+import { z as z5 } from "zod";
+var jsonPatchSchema = z5.array(
+  z5.object({
+    op: z5.enum(["add", "remove", "replace"]),
+    path: z5.string().describe("The JSON path to patch"),
+    value: z5.any().describe("The value to patch - for remove, leave this blank")
+  })
+);
+
+// src/tools/components/util.ts
+import { z as z6 } from "zod";
+var aiComponentDefinitionSchema = z6.object({
+  name: z6.string().describe('Title-cased display name of the component. Ex: "Hero"'),
+  id: z6.string().describe(
+    "Public ID of the component, the camelCase version of name, using only alphanumeric characters"
+  ),
+  description: z6.string().describe(
+    'Describe the purpose of the component in 1-2 sentences. If the component seems generic, such as "Promo" or "Hero", this should be blank.'
+  ),
+  canBeComposition: z6.boolean().describe(
+    "True if the component can have pages/compositions created from it. False if it is a part of a page."
+  ),
+  parameters: z6.array(propertyDefinitionSchema).describe("The properties of the component. The key is the publicId of the property.").optional(),
+  slots: z6.array(
+    z6.object({
+      name: z6.string().describe('Title-cased display name of the slot. Ex: "Content"'),
+      id: z6.string().describe("The public id of the slot. Must be unique within this component's slots."),
+      allowedComponents: z6.array(z6.string()).describe("The components public IDs allowed in the slot."),
+      minComponents: z6.number().describe("The minimum number of components allowed in the slot. 0 for no minimum.").optional(),
+      maxComponents: z6.number().describe("The maximum number of components allowed in the slot. 0 for no maximum.").optional(),
+      inheritAllowedComponents: z6.boolean().describe("Set to false")
+    })
+  ).describe("The slots of the component. The key is the publicId of the slot.").optional()
+});
+function applyDefaultsForNewAiCreatedUniformComponents(component) {
+  const slots = component.slots?.map((slot) => {
+    return {
+      ...slot,
+      patternsInAllowedComponents: true,
+      inheritAllowedComponents: false
+    };
+  });
+  const thumbnailParameter = component.parameters?.find(
+    (property) => property.type === "asset" && typeof property.typeConfig === "object" && property.typeConfig !== null && "allowedTypes" in property.typeConfig && Array.isArray(property.typeConfig.allowedTypes) && property.typeConfig.allowedTypes?.includes("image")
+  )?.id;
+  const titleParameter = component.parameters?.find((property) => property.type === "text")?.id;
+  return {
+    ...component,
+    slots,
+    titleParameter,
+    thumbnailParameter
+  };
+}
+function linkToComponentDefinition(id) {
+  return `${env.baseWebUrl}/dashboards/canvas/components/${id}`;
+}
+
+// src/tools/components/componentAction.ts
+var componentActionSchema = {
+  action: z7.enum(["create", "update", "delete"]).describe("The action to perform"),
+  publicId: z7.string().describe(
+    "Public ID of the component, the camelCase version of name, using only alphanumeric characters"
+  ),
+  component: aiComponentDefinitionSchema.describe("Full component definition to create. Omit for update or delete.").optional(),
+  patches: jsonPatchSchema.describe("JSON patch to apply to the existing component definition. Omit for create or delete.").optional()
+};
+function registerComponentAction(server2) {
+  server2.tool(
+    "componentAction",
+    "Creates, updates, or deletes a Uniform Component definition (or Composition definition)",
+    componentActionSchema,
+    async ({ publicId, action, component, patches }) => {
+      const canvasClient = new CanvasClient3(env);
+      if (action === "create") {
+        if (!component) {
+          throw new Error("Component definition is required for create");
+        }
+        await canvasClient.updateComponentDefinition({
+          componentDefinition: applyDefaultsForNewAiCreatedUniformComponents(component)
+        });
+      }
+      if (action === "update") {
+        if (!patches) {
+          throw new Error("Patches are required for update");
+        }
+        const existingComponent = await canvasClient.getComponentDefinitions({ componentId: publicId });
+        if (!existingComponent.componentDefinitions.length) {
+          throw new Error(`Component with public ID ${publicId} does not exist, try creating it instead`);
+        }
+        const existingComponentDefinitionToPatch = existingComponent.componentDefinitions[0];
+        const newDocument = applyJsonPatch(existingComponentDefinitionToPatch, patches);
+        await canvasClient.updateComponentDefinition({
+          componentDefinition: newDocument
+        });
+      }
+      if (action === "delete") {
+        await canvasClient.removeComponentDefinition({ componentId: publicId });
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true, editUrl: linkToComponentDefinition(publicId) }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/components/componentList.ts
+import { CanvasClient as CanvasClient4 } from "@uniformdev/canvas";
+function registerComponentList(server2) {
+  server2.tool("componentList", "Lists all Uniform Component definitions", async () => {
+    const canvasClient = new CanvasClient4(env);
+    const components = await canvasClient.getComponentDefinitions();
+    const toolResult = components.componentDefinitions.map((component) => ({
+      componentDefinition: component,
+      editUrl: linkToComponentDefinition(component.id)
+    }));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(toolResult, null, 2)
+        }
+      ]
+    };
+  });
+}
+
+// src/tools/contentTypes/contentTypeAction.ts
+import { ContentClient } from "@uniformdev/canvas";
+import { z as z9 } from "zod";
+
+// src/tools/contentTypes/util.ts
+import { z as z8 } from "zod";
+var aiContentTypeDefinitionSchema2 = z8.object({
+  name: z8.string().describe('Title-cased display name of the component. Ex: "Hero"'),
+  id: z8.string().describe(
+    "Public ID of the content type, the camelCase version of name, using only alphanumeric characters"
+  ),
+  description: z8.string().describe("Describe the purpose of the content type in 1-2 sentences."),
+  fields: z8.array(propertyDefinitionSchema).describe("The fields of the content type. The key is the publicId of the field.").optional()
+});
+function applyDefaultsForNewAiCreatedUniformContentTypes(contentType) {
+  const thumbnailField = contentType.fields?.find(
+    (property) => property.type === "asset" && typeof property.typeConfig === "object" && property.typeConfig !== null && "allowedTypes" in property.typeConfig && Array.isArray(property.typeConfig.allowedTypes) && property.typeConfig.allowedTypes?.includes("image")
+  )?.id;
+  const entryName = contentType.fields?.find((field) => field.type === "text")?.id;
+  return {
+    ...contentType,
+    thumbnailField,
+    entryName
+  };
+}
+function linkToContentType(id) {
+  return `${env.baseWebUrl}/dashboards/canvas/content-types/${id}`;
+}
+
+// src/tools/contentTypes/contentTypeAction.ts
+var contentTypeActionSchema = {
+  action: z9.enum(["create", "update", "delete"]).describe("The action to perform"),
+  publicId: z9.string().describe(
+    "Public ID of the component, the camelCase version of name, using only alphanumeric characters"
+  ),
+  contentType: aiContentTypeDefinitionSchema2.describe("Full content type definition to create. Omit for update or delete.").optional(),
+  patches: jsonPatchSchema.describe("JSON patch to apply to the existing component definition. Omit for create or delete.").optional()
+};
+function registerContentTypeAction(server2) {
+  server2.tool(
+    "contentTypeAction",
+    "Creates, updates, or deletes a Uniform Content Type definition",
+    contentTypeActionSchema,
+    async ({ publicId, action, contentType, patches }) => {
+      const contentClient = new ContentClient(env);
+      if (action === "create") {
+        if (!contentType) {
+          throw new Error("Content type definition is required for create");
+        }
+        await contentClient.upsertContentType({
+          contentType: applyDefaultsForNewAiCreatedUniformContentTypes(contentType)
+        });
+      }
+      if (action === "update") {
+        if (!patches) {
+          throw new Error("Patches are required for update");
+        }
+        const existingContentTypes = await contentClient.getContentTypes();
+        const existingContentType = existingContentTypes.contentTypes.find(
+          (contentType2) => contentType2.id === publicId
+        );
+        if (!existingContentType) {
+          throw new Error(`Content Type with public ID ${publicId} does not exist, try creating it instead`);
+        }
+        const newDocument = applyJsonPatch(existingContentType, patches);
+        await contentClient.upsertContentType({
+          contentType: newDocument
+        });
+      }
+      if (action === "delete") {
+        await contentClient.deleteContentType({ contentTypeId: publicId });
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true, editUrl: linkToContentType(publicId) }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/contentTypes/contentTypeList.ts
+import { ContentClient as ContentClient2 } from "@uniformdev/canvas";
+function registerContentTypeList(server2) {
+  server2.tool("contentTypeList", "Lists all Uniform Content Type definitions", async () => {
+    const contentClient = new ContentClient2(env);
+    const components = await contentClient.getContentTypes();
+    const toolResult = components.contentTypes.map((contentType) => ({
+      contentType,
+      editUrl: linkToContentType(contentType.id)
+    }));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(toolResult, null, 2)
+        }
+      ]
+    };
+  });
+}
+
+// src/index.ts
+var server = new McpServer({
+  name: "Uniform MCP",
+  version: "1.0.0"
+});
+registerComponentAction(server);
+registerComponentList(server);
+registerContentTypeAction(server);
+registerContentTypeList(server);
+registerComponentPatternList(server);
+registerComponentPatternAction(server);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+process.stderr.write("Uniform MCP server started\n");

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@uniformdev/uniform-mcp",
+  "version": "20.14.2-alpha.35+298a00bb0a",
+  "description": "Uniform MCP Server",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "main": "./dist/index.js",
+  "module": "./dist/index.esm.js",
+  "type": "module",
+  "bin": {
+    "uniform-mcp": "./dist/index.js"
+  },
+  "exports": {
+    "types": "./dist/index.d.mts",
+    "default": "./dist/index.js"
+  },
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rimraf dist",
+    "test": "vitest --passWithNoTests",
+    "lint": "eslint \"src/**/*.{js,ts,tsx}\"",
+    "format": "prettier --write \"src/**/*.{js,ts,tsx}\"",
+    "mcp": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@uniformdev/canvas": "20.14.2-alpha.35+298a00bb0a",
+    "fast-json-patch": "^3.1.1",
+    "immer": "10.1.1",
+    "zod": "3.23.8"
+  },
+  "files": [
+    "/dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "vitest": "^3.1.4"
+  },
+  "gitHead": "298a00bb0a2955cf07d94dd6ef939a64b5bfdcd0"
+}