@zeroheight/mcp-server 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+## Release notes
+
+## [1.0.0](https://www.npmjs.com/package/@zeroheight/mcp-server/v/1.0.0) - 12th August 2025
+
+- Create the zeroheight MCP server with support for retrieving styleguide navigation and page content.

package/README.md

@@ -0,0 +1,103 @@
+# zeroheight MCP Server
+
+MCP server for zeroheight
+
+**For a full walkthrough on how to use this MCP server, head over to our [help centre article](https://help.zeroheight.com/hc/en-us/articles/39914754674843-Using-the-zeroheight-MCP-server).**
+
+## Install
+
+Add to Claude Desktop or VSCode (including Cursor/Windsurf) config:
+
+```json
+"mcpServers": {
+  "zeroheight": {
+    "command": "npx",
+    "args": ["-y", "@zeroheight/mcp-server@latest"],
+    "env": {
+      "ZEROHEIGHT_ACCESS_TOKEN": "zhat_abc123",
+      "ZEROHEIGHT_CLIENT_ID": "zhci_abc123"
+    }
+  }
+}
+```
+
+## Usage
+
+### Authentication
+
+You will need to add your zeroheight authentication credentials as environment variables, which can be created using [these instructions](https://developers.zeroheight.com/75fe5b2ed/p/6599ef-creation):
+
+```
+ZEROHEIGHT_CLIENT_ID="your-client-id"
+ZEROHEIGHT_ACCESS_TOKEN="your-access-token"
+```
+
+### Available Tools
+
+The server provides these MCP tools:
+
+**list-styleguides**
+List all accessible styleguides as resource links or markdown
+
+**get-styleguide-tree**
+Get a navigation hierarchy for a styleguide with top-level navigation, categories, pages and tabs
+
+**list-pages**
+List all accessible pages in a styleguide with optional search
+
+**get-page**
+Get a styleguide page in the requested format (markdown or JSON)
+
+### Setup Examples
+
+#### Claude Desktop
+
+```json
+{
+  "mcpServers": {
+    "zeroheight": {
+      "command": "npx",
+      "args": ["-y", "@zeroheight/mcp-server@latest"],
+      "env": {
+        "ZEROHEIGHT_ACCESS_TOKEN": "zhat_abc123",
+        "ZEROHEIGHT_CLIENT_ID": "zhci_abc123"
+      }
+    }
+  }
+}
+```
+
+#### VS Code
+
+Create `.vscode/mcp.json`:
+
+```json
+{
+  "servers": {
+    "zeroheight": {
+      "command": "npx",
+      "args": ["-y", "@zeroheight/mcp-server@latest"],
+      "env": {
+        "ZEROHEIGHT_ACCESS_TOKEN": "zhat_abc123",
+        "ZEROHEIGHT_CLIENT_ID": "zhci_abc123"
+      }
+    }
+  }
+}
+```
+
+## Example Usage
+
+```
+"List my styleguides"
+"Show pages about buttons"
+"Get the navigation for [styleguide name]"
+"Find documentation about typography"
+```
+
+## Requirements
+
+- Node.js 22+
+- zeroheight Client ID and Access Token
+
+More info on setup can be found in the [help centre article](https://help.zeroheight.com/hc/en-us).

package/dist/api/api.js

@@ -0,0 +1,77 @@
+import { IncorrectScopeError, MaxRetriesError, UnauthorizedError, UnknownError, } from "./errors.js";
+import packageJson from "../../package.json" with { type: "json" };
+const API_PATH = "/open_api/v2";
+const USER_AGENT = `zeroheight-mcp-server/${packageJson.version}`;
+export var ResponseStatus;
+(function (ResponseStatus) {
+    ResponseStatus["Success"] = "success";
+    ResponseStatus["Error"] = "error";
+    ResponseStatus["Fail"] = "fail";
+})(ResponseStatus || (ResponseStatus = {}));
+/**
+ * Get the correct URL for production of development depending on the environment variable
+ */
+export function getZeroheightURL() {
+    if (process.env["NODE_ENV"] === "dev") {
+        return new URL("https://zeroheight.dev");
+    }
+    else {
+        return new URL("https://zeroheight.com");
+    }
+}
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function request(path, credentials, init, search) {
+    const url = getZeroheightURL();
+    url.pathname = API_PATH + path;
+    if (search) {
+        url.search = "?" + search.toString();
+    }
+    if (process.env["NODE_ENV"] === "dev") {
+        process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = "0";
+    }
+    const maxRetries = 3;
+    let retries = 0;
+    while (retries < maxRetries) {
+        const response = await fetch(url, {
+            ...init,
+            headers: {
+                "X-API-CLIENT-NAME": "mcp-server",
+                "X-API-CLIENT": credentials.client,
+                "X-API-KEY": credentials.token,
+                "X-API-CLIENT-VERSION": packageJson.version,
+                "User-Agent": USER_AGENT,
+                "Content-Type": "application/json",
+                Accept: "application/json",
+            },
+        });
+        if (response.status === 401) {
+            console.error("Unauthorized response from API", {
+                response: { status: response.status, body: await response.text() },
+            });
+            throw new UnauthorizedError();
+        }
+        else if (response.status === 429) {
+            retries++;
+            const responseData = await response.json();
+            const waitTime = responseData.data.reset_time * 1000 - Date.now();
+            await sleep(waitTime);
+            continue;
+        }
+        else if (response.status < 200 || response.status >= 300) {
+            console.error("API request failed", {
+                response: { status: response.status, body: await response.text() },
+            });
+            if (response.status === 403) {
+                throw new IncorrectScopeError();
+            }
+            else {
+                throw new UnknownError();
+            }
+        }
+        const responseJson = await response.json();
+        return responseJson;
+    }
+    throw new MaxRetriesError();
+}

package/dist/api/api.test.js

@@ -0,0 +1,12 @@
+import { expect, describe, it } from "@rstest/core";
+import { getZeroheightURL } from "./api.js";
+describe("getZeroheightURL", () => {
+    it("uses local development domain when NODE_ENV is dev", () => {
+        process.env.NODE_ENV = "dev";
+        expect(getZeroheightURL().toString()).toBe("https://zeroheight.dev/");
+    });
+    it("uses local development domain when NODE_ENV is dev", () => {
+        process.env.NODE_ENV = "production";
+        expect(getZeroheightURL().toString()).toBe("https://zeroheight.com/");
+    });
+});

package/dist/api/errors.js

@@ -0,0 +1,26 @@
+export class ApiError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ApiError";
+    }
+}
+export class UnauthorizedError extends ApiError {
+    constructor() {
+        super("Unauthorized. Please ensure you have added your credentials.");
+    }
+}
+export class IncorrectScopeError extends ApiError {
+    constructor() {
+        super("The authentication token used does not have the correct scope. \n\nPlease create a new authentication token with the relevant scopes and then update your credentials.");
+    }
+}
+export class UnknownError extends ApiError {
+    constructor() {
+        super("An unknown error occurred while calling the zeroheight API");
+    }
+}
+export class MaxRetriesError extends ApiError {
+    constructor() {
+        super("Max retries exceeded while calling the zeroheight API");
+    }
+}

package/dist/api/page.js

@@ -0,0 +1,46 @@
+import { getCredentialsFromEnvironment } from "../common/credentials.js";
+import { request } from "./api.js";
+import { UnknownError } from "./errors.js";
+export async function listPages(styleguideId, optionalParams = {}) {
+    try {
+        const credentials = getCredentialsFromEnvironment();
+        const searchParams = new URLSearchParams();
+        if (optionalParams.releaseId) {
+            searchParams.set("release_id", optionalParams.releaseId.toString());
+        }
+        if (optionalParams.searchTerm) {
+            searchParams.set("search", optionalParams.searchTerm);
+        }
+        const response = await request(`/styleguides/${styleguideId}/pages`, credentials, {
+            method: "GET",
+        }, searchParams);
+        if ("pages" in response.data) {
+            return response.data.pages;
+        }
+        throw new UnknownError();
+    }
+    catch (e) {
+        console.error(e);
+        return [];
+    }
+}
+export async function getPage(pageId, optionalParams = {}) {
+    try {
+        const credentials = getCredentialsFromEnvironment();
+        const searchParams = new URLSearchParams();
+        if (optionalParams.releaseId) {
+            searchParams.set("release_id", optionalParams.releaseId.toString());
+        }
+        const response = await request(`/pages/${pageId}`, credentials, {
+            method: "GET",
+        }, searchParams);
+        if ("page" in response.data) {
+            return response.data.page;
+        }
+        throw new UnknownError();
+    }
+    catch (e) {
+        console.error(e);
+        return null;
+    }
+}

package/dist/api/styleguide.js

@@ -0,0 +1,36 @@
+import { request } from "./api.js";
+import { UnknownError } from "./errors.js";
+import { getCredentialsFromEnvironment } from "../common/credentials.js";
+export async function listStyleguides() {
+    try {
+        const credentials = getCredentialsFromEnvironment();
+        const response = await request("/styleguides", credentials, {
+            method: "GET",
+        });
+        if ("styleguides" in response.data) {
+            return response.data.styleguides;
+        }
+        throw new UnknownError();
+    }
+    catch (e) {
+        console.error(e);
+        return [];
+    }
+}
+export async function getStyleguideTree(id) {
+    try {
+        const credentials = getCredentialsFromEnvironment();
+        const response = await request(`/styleguides/${id}/tree`, credentials, {
+            method: "GET",
+        });
+        if ("tree" in response.data) {
+            return response.data.tree;
+        }
+        console.error(response);
+        throw new UnknownError();
+    }
+    catch (e) {
+        console.error(e);
+        return [];
+    }
+}

package/dist/api/types/page.js

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

package/dist/api/types/styleguide.js

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

package/dist/common/credentials.js

@@ -0,0 +1,12 @@
+import { MissingCredentialsError } from "./errors.js";
+export function getCredentialsFromEnvironment() {
+    const token = process.env["ZEROHEIGHT_ACCESS_TOKEN"];
+    const client = process.env["ZEROHEIGHT_CLIENT_ID"];
+    if (!token || !client) {
+        throw new MissingCredentialsError();
+    }
+    return {
+        token,
+        client,
+    };
+}

package/dist/common/errors.js

@@ -0,0 +1,11 @@
+export class ServerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ServerError";
+    }
+}
+export class MissingCredentialsError extends ServerError {
+    constructor() {
+        super("Missing credentials. Please ensure ZEROHEIGHT_CLIENT_ID and ZEROHEIGHT_ACCESS_TOKEN are set in your environment");
+    }
+}

package/dist/common/formatters/page.js

@@ -0,0 +1,16 @@
+export function formatPageAsMarkdown(page) {
+    const content = page.content ||
+        page.tabs?.map((tab) => `## ${tab.name}\n${tab.content}\n---\n`).join("\n");
+    return [
+        `# ${page.name}`,
+        `[Web URL](${page.url})`,
+        page.introduction,
+        "\n",
+        content,
+    ].join("\n");
+}
+export function formatPageListItemsAsMarkdown(pages) {
+    return pages
+        .map((page) => `- ${page.name ?? "Untitled page"} (ID: ${page.id})`)
+        .join("\n");
+}

package/dist/common/formatters/styleguide.js

@@ -0,0 +1,25 @@
+export const DEFAULT_NAME = "Unnamed styleguide";
+export function formatTreeAsJson(tree) {
+    return (tree?.map((node) => {
+        if (node.type === "page" || node.type === "tab") {
+            return {
+                id: node.id,
+                type: node.type,
+                name: node.name,
+                url: node.url,
+                children: formatTreeAsJson(node.children),
+            };
+        }
+        return {
+            id: node.id,
+            type: node.type,
+            name: node.name,
+            children: formatTreeAsJson(node.children),
+        };
+    }) ?? []);
+}
+export function formatStyleguideListAsMarkdown(styleguides) {
+    return styleguides
+        .map((styleguide) => `- ${styleguide.name ?? DEFAULT_NAME} (ID: ${styleguide.id})`)
+        .join("\n");
+}

package/dist/common/formatters/styleguide.test.js

@@ -0,0 +1,24 @@
+import { expect, describe, it } from "@rstest/core";
+import { formatStyleguideListAsMarkdown } from "./styleguide.js";
+describe("formatStyleguideListAsMarkdown", () => {
+    describe("when list is empty", () => {
+        it("returns an empty string", () => {
+            expect(formatStyleguideListAsMarkdown([])).toBe("");
+        });
+    });
+    describe("when there's one styleguide", () => {
+        it("formats styleguide list as markdown list on one line", () => {
+            expect(formatStyleguideListAsMarkdown([
+                { id: 1, name: "Styleguide 1", team_id: 1, share_id: "abc123" },
+            ])).toBe("- Styleguide 1 (ID: 1)");
+        });
+    });
+    describe("when there's multiple styleguides", () => {
+        it("formats styleguide list as markdown list", () => {
+            expect(formatStyleguideListAsMarkdown([
+                { id: 1, name: "Styleguide 1", team_id: 1, share_id: "abc123" },
+                { id: 2, name: "Styleguide 2", team_id: 1, share_id: "xyz987" },
+            ])).toBe("- Styleguide 1 (ID: 1)\n- Styleguide 2 (ID: 2)");
+        });
+    });
+});

package/dist/index.js

@@ -0,0 +1,48 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import packageJson from "../package.json" with { type: "json" };
+import { registerStyleguideListResource, registerStyleguideResource, } from "./resources/styleguide.js";
+import { registerListPagesResource, registerPageResource, } from "./resources/page.js";
+import { registerGetStyleguideTreeTool, registerListStyleguidesTool, } from "./tools/styleguide.js";
+import { registerGetPageTool, registerListPagesTool } from "./tools/page.js";
+import { recommendSummarizePagePrompt } from "./prompts/page.js";
+import { registerRecommendPagesPrompt } from "./prompts/styleguide.js";
+function createServer() {
+    // Create server instance
+    const server = new McpServer({
+        name: "zeroheight",
+        version: packageJson.version,
+        capabilities: {
+            resources: {},
+            tools: {},
+        },
+    });
+    // Register all tools
+    [
+        registerListPagesTool,
+        registerGetPageTool,
+        registerListStyleguidesTool,
+        registerGetStyleguideTreeTool,
+    ].forEach((fn) => fn(server));
+    // Register all resources
+    [
+        registerStyleguideListResource,
+        registerStyleguideResource,
+        registerListPagesResource,
+        registerPageResource,
+    ].forEach((fn) => fn(server));
+    // Register all prompts
+    [registerRecommendPagesPrompt, recommendSummarizePagePrompt].forEach((fn) => fn(server));
+    return server;
+}
+// Start server on STDIO
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("zeroheight MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/prompts/page.js

@@ -0,0 +1,28 @@
+import z from "zod";
+export function recommendSummarizePagePrompt(server) {
+    server.registerPrompt("summarize-page", {
+        title: "Summarize Page",
+        description: "Give a TLDR page summary",
+        argsSchema: {
+            pageId: z.string(),
+            releaseId: z.string().optional(),
+        },
+    }, ({ pageId, releaseId }) => ({
+        messages: [
+            {
+                role: "assistant",
+                content: {
+                    type: "text",
+                    text: "Your goal is to find the page in zeroheight and summarize it.",
+                },
+            },
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Summarize the following page: ${pageId}.${releaseId ? `Get the page from this release: ${releaseId}` : ""}`,
+                },
+            },
+        ],
+    }));
+}

package/dist/prompts/styleguide.js

@@ -0,0 +1,28 @@
+import z from "zod";
+export function registerRecommendPagesPrompt(server) {
+    server.registerPrompt("recommend-pages", {
+        title: "Recommend Pages",
+        description: "Find useful pages on a given topic",
+        argsSchema: {
+            styleguideId: z.string(),
+            topic: z.string(),
+        },
+    }, ({ styleguideId, topic }) => ({
+        messages: [
+            {
+                role: "assistant",
+                content: {
+                    type: "text",
+                    text: "Your goal is to find pages in a styleguide and recommend the top 5 most relevant to the given task.",
+                },
+            },
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Look at the navigation tree for this styleguide: ${styleguideId}.\n\nReturn the URLs for the top 5 most relevant pages about this topic: ${topic}.`,
+                },
+            },
+        ],
+    }));
+}

package/dist/resources/page.js

@@ -0,0 +1,74 @@
+/**
+ * Page Resources
+ */
+import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { completionForStyleduideId, listStyleguideResources, } from "./styleguide.js";
+import { getPage, listPages } from "../api/page.js";
+import { formatPageAsMarkdown } from "../common/formatters/page.js";
+export function registerListPagesResource(server) {
+    server.registerResource("styleguide-page-list", new ResourceTemplate("zeroheight://styleguide/{styleguideId}/page-list", {
+        list: listStyleguideResources,
+        complete: {
+            styleguideId: completionForStyleduideId,
+        },
+    }), {
+        title: "List the pages for a styleguide",
+        description: "List all pages in a styleguide",
+        mimeType: "text/markdown",
+    }, async (uri, { styleguideId }) => {
+        const selectedId = Array.isArray(styleguideId)
+            ? styleguideId[0]
+            : styleguideId;
+        const parsedStyleguideId = parseInt(selectedId, 10);
+        const pages = await listPages(parsedStyleguideId);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: pages
+                        .map((page) => `- ${page.name} (id: ${page.id})`)
+                        .join("\n"),
+                },
+            ],
+        };
+    });
+}
+export function registerPageResource(server) {
+    server.registerResource("page", new ResourceTemplate("zeroheight://styleguide/{styleguideId}/page/{pageId}", {
+        list: undefined,
+        complete: {
+            styleguideId: completionForStyleduideId,
+            pageId: completionForStyleduideId,
+        },
+    }), {
+        title: "Page",
+        description: "Design system page",
+        mimeType: "text/markdown",
+    }, async (uri, { pageId }) => {
+        const selectedId = Array.isArray(pageId) ? pageId[0] : pageId;
+        const parsedPageId = parseInt(selectedId, 10);
+        const page = await getPage(parsedPageId);
+        if (!page) {
+            throw new Error("Couldn't find the page");
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: formatPageAsMarkdown(page),
+                    mimeType: "text/markdown",
+                },
+            ],
+        };
+    });
+}
+/** Utils */
+export async function completionForPageId(searchTerm, context) {
+    const styleguideId = parseInt(context.arguments?.styleguideId ?? "", 10);
+    const pageList = await listPages(styleguideId);
+    const matchingPages = pageList.filter((page) => page.id
+        .toString()
+        .toLocaleLowerCase()
+        .includes(searchTerm.toLocaleLowerCase()));
+    return matchingPages.map((page) => page.id.toString());
+}

package/dist/resources/styleguide.js

@@ -0,0 +1,87 @@
+/**
+ * Styleguide Resources
+ */
+import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { getStyleguideTree, listStyleguides } from "../api/styleguide.js";
+import { DEFAULT_NAME, formatTreeAsJson, } from "../common/formatters/styleguide.js";
+export function registerStyleguideListResource(server) {
+    server.registerResource("styleguide-list", "zeroheight://styleguide/list", {
+        title: "Styleguide list",
+        description: "List all accessible styleguides",
+        mimeType: "application/json",
+    }, async (uri) => {
+        const styleguideList = await listStyleguides();
+        const styleguideResources = styleguideList.map((styleguide) => ({
+            id: styleguide.id,
+            name: styleguide.name ?? DEFAULT_NAME,
+        }));
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: JSON.stringify(styleguideResources, null, 2),
+                    mimeType: "application/json",
+                },
+            ],
+        };
+    });
+}
+export function registerStyleguideResource(server) {
+    server.registerResource("styleguide", new ResourceTemplate("zeroheight://styleguide/{styleguideId}", {
+        list: undefined,
+        complete: {
+            styleguideId: completionForStyleduideId,
+        },
+    }), {
+        title: "Styleguide Navigation",
+        description: "Access the styleguide's navigation including categories, pages and tabs",
+    }, async (uri, { styleguideId }) => {
+        console.log({ uri, styleguideId });
+        const selectedId = Array.isArray(styleguideId)
+            ? styleguideId[0]
+            : styleguideId;
+        console.log({ selectedId });
+        const parsedStyleguideId = parseInt(selectedId, 10);
+        // TODO: Make endpoint to get basic styleguide info instead
+        const styleguideList = await listStyleguides();
+        console.log({ styleguideList });
+        const currentStyleguide = styleguideList.find((styleguide) => styleguide.id === parsedStyleguideId);
+        if (!currentStyleguide) {
+            return { contents: [] };
+        }
+        const tree = await getStyleguideTree(parsedStyleguideId);
+        const formattedTree = formatTreeAsJson(tree);
+        return {
+            contents: [
+                {
+                    mimeType: "application/json",
+                    uri: uri.href,
+                    text: JSON.stringify(formattedTree, null, 2),
+                },
+            ],
+        };
+    });
+}
+/** Utils */
+export async function completionForStyleduideId(searchTerm) {
+    const styleguideList = await listStyleguides();
+    const matchingStyleguides = styleguideList.filter((styleguide) => styleguide.id
+        .toString()
+        .toLocaleLowerCase()
+        .includes(searchTerm.toLocaleLowerCase()));
+    return matchingStyleguides.map((styleguide) => styleguide.id.toString());
+}
+export async function listStyleguideResources() {
+    const styleguideList = await listStyleguides();
+    const resources = styleguideList.map((styleguide) => ({
+        uri: `zeroheight://styleguide/${styleguide.id}`,
+        name: `${styleguide.name ?? DEFAULT_NAME}`,
+        _meta: {
+            id: styleguide.id,
+            shareId: styleguide.share_id,
+        },
+    }));
+    return {
+        resources,
+    };
+}

package/dist/tools/page.js

@@ -0,0 +1,108 @@
+/**
+ * Page Tools
+ */
+import z from "zod";
+import { getPage, listPages } from "../api/page.js";
+import { formatPageAsMarkdown, formatPageListItemsAsMarkdown, } from "../common/formatters/page.js";
+export function registerListPagesTool(server) {
+    server.registerTool("list-pages", {
+        title: "List pages for a styleguide",
+        description: "List all accessible pages in a styleguide",
+        inputSchema: {
+            styleguideId: z.number().int().positive(),
+            releaseId: z.number().int().optional(),
+            searchTerm: z.string().optional(),
+            responseFormat: z
+                .enum(["markdown", "resource_links"])
+                .default("markdown"),
+        },
+    }, async ({ styleguideId, releaseId, searchTerm, responseFormat }) => {
+        const pages = await listPages(styleguideId, { releaseId, searchTerm });
+        if (pages.length === 0) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: "There are no pages in this styleguide, check you have the correct styleguide ID",
+                    },
+                ],
+            };
+        }
+        if (responseFormat === "markdown") {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatPageListItemsAsMarkdown(pages),
+                        mimeType: "text/markdown",
+                    },
+                ],
+            };
+        }
+        const resourceLinks = pages.map((page) => ({
+            type: "resource_link",
+            uri: `zeroheight://styleguide/${styleguideId}/page/${page.id}`,
+            name: page.name ?? "Unnamed Page",
+            _meta: {
+                createdAt: page.created_at,
+                id: page.id,
+            },
+            mimeType: "text/markdown",
+            description: "Styleguide page",
+        }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `There are ${pages.length} pages in the styleguide: `,
+                },
+                ...resourceLinks,
+            ],
+        };
+    });
+}
+export function registerGetPageTool(server) {
+    server.registerTool("get-page", {
+        title: "Get a styleguide page",
+        description: "Get a page in the requested format",
+        inputSchema: {
+            pageId: z.string(),
+            releaseId: z.number().int().optional(),
+            responseFormat: z.enum(["markdown", "json"]).default("json"),
+        },
+    }, async ({ pageId, responseFormat }) => {
+        const page = await getPage(pageId);
+        if (!page) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: "Could not find the page, check you have the correct page ID and release ID.",
+                    },
+                ],
+            };
+        }
+        if (responseFormat === "markdown") {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatPageAsMarkdown(page),
+                        mimeType: "text/markdown",
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(page, null, 2),
+                    mimeType: "application/json",
+                },
+            ],
+        };
+    });
+}

package/dist/tools/styleguide.js

@@ -0,0 +1,94 @@
+/**
+ * Styleguide Tools
+ */
+import z from "zod";
+import { getStyleguideTree, listStyleguides } from "../api/styleguide.js";
+import { DEFAULT_NAME, formatStyleguideListAsMarkdown, formatTreeAsJson, } from "../common/formatters/styleguide.js";
+export function registerListStyleguidesTool(server) {
+    server.registerTool("list-styleguides", {
+        title: "List styleguides",
+        description: "List all accessible styleguides as resource links",
+        inputSchema: {
+            responseType: z
+                .enum(["markdown", "resource_links"])
+                .default("markdown"),
+        },
+    }, async ({ responseType }) => {
+        const styleguides = await listStyleguides();
+        if (styleguides.length === 0) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: "There are no accessible styleguides. Check your auth credentials and make sure you have at least one styleguide in zeroheight.",
+                    },
+                ],
+            };
+        }
+        if (responseType === "markdown") {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatStyleguideListAsMarkdown(styleguides),
+                        mimeType: "text/markdown",
+                    },
+                ],
+            };
+        }
+        const resourceLinks = styleguides.map((styleguide) => ({
+            type: "resource_link",
+            uri: `zeroheight://styleguide/${styleguide.id}`,
+            name: styleguide.name ?? DEFAULT_NAME,
+            _meta: {
+                shareId: styleguide.share_id,
+                id: styleguide.id,
+            },
+            mimeType: "application/json",
+            description: "Navigation structure for the styleguide",
+        }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `There are available ${styleguides.length} styleguides`,
+                },
+                ...resourceLinks,
+            ],
+        };
+    });
+}
+export function registerGetStyleguideTreeTool(server) {
+    server.registerTool("get-styleguide-tree", {
+        title: "Get styleguide tree",
+        description: "A navigation hierarchy for a styleguide with top-level navigation, categories, pages and tabs",
+        inputSchema: {
+            styleguideId: z.number().int().positive(),
+        },
+    }, async ({ styleguideId }) => {
+        try {
+            const tree = await getStyleguideTree(styleguideId);
+            const formattedTree = formatTreeAsJson(tree);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(formattedTree, null, 2),
+                    },
+                ],
+            };
+        }
+        catch {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: "Could not get the navigation tree for this styleguide.",
+                    },
+                ],
+            };
+        }
+    });
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@zeroheight/mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for zeroheight",
+  "type": "module",
+  "bin": {
+    "mcp-server": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && chmod 755 dist/index.js",
+    "start": "node dist/index.js",
+    "cleanup": "rm -rf dist",
+    "lint": "prettier --write .",
+    "test": "rstest"
+  },
+  "engines": {
+    "node": ">= 22"
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "keywords": [],
+  "author": "zeroheight",
+  "license": "ISC",
+  "bugs": {
+    "email": "support@zeroheight.com"
+  },
+  "homepage": "https://zeroheight.com",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.1",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@rstest/core": "^0.1.2",
+    "@types/node": "^24.2.0",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2"
+  }
+}