everymuseum-mcp 0.1.0

package/dist/images.js

@@ -0,0 +1,130 @@
+import { API_BASE } from "./api.js";
+const IMAGE_TIMEOUT_MS = 20_000;
+const MAX_IMAGE_BYTES = 6 * 1024 * 1024; // 6 MB — generous for a sized JPEG.
+const USER_AGENT = "everymuseum-mcp/0.1 (+https://everymuseum.org)";
+// MIME types Claude can render as image content blocks.
+const SUPPORTED_IMAGE_TYPES = new Set([
+    "image/jpeg",
+    "image/png",
+    "image/gif",
+    "image/webp",
+]);
+/**
+ * The app rewrites some image URLs to relative proxy paths (e.g.
+ * `/api/media/te-papa/...`). Resolve those against the API base so they fetch.
+ */
+export function resolveUrl(url) {
+    if (!url)
+        return null;
+    const trimmed = url.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+        return trimmed;
+    }
+    if (trimmed.startsWith("/")) {
+        return `${API_BASE}${trimmed}`;
+    }
+    return null;
+}
+/** Rewrite a IIIF "full" image URL to a bounded `!w,h` derivative. */
+function resizeIiifFullUrl(url, size) {
+    const resized = url.replace(/\/full\/[^/]+\/0\/default\.(jpe?g|png|webp)(\?.*)?$/i, `/full/!${size},${size}/0/default.$1$2`);
+    return resized === url ? null : resized;
+}
+/** Turn a IIIF base/info/full URL into a sized JPEG derivative. */
+function iiifImageUrl(value, size) {
+    const url = value?.trim();
+    if (!url)
+        return null;
+    if (url.includes("/presentation/"))
+        return null;
+    if (url.endsWith("/info.json")) {
+        return url.replace(/\/info\.json$/, `/full/!${size},${size}/0/default.jpg`);
+    }
+    const resized = resizeIiifFullUrl(url, size);
+    if (resized)
+        return resized;
+    if (url.includes("/full/"))
+        return url; // already a full-spec URL
+    // Treat as a IIIF image service base.
+    return `${url.replace(/\/$/, "")}/full/!${size},${size}/0/default.jpg`;
+}
+/**
+ * Pick the best URL to display an artwork at roughly `size` px on its long edge.
+ * IIIF sources are sized exactly on demand; others fall back to the stored
+ * derivative (small thumbnail for grids, full image for detail views).
+ */
+export function bestDisplayUrl(artwork, size) {
+    const fromIiif = iiifImageUrl(artwork.iiifUrl, size);
+    if (fromIiif)
+        return resolveUrl(fromIiif);
+    const resizedFull = artwork.imageUrl ? resizeIiifFullUrl(artwork.imageUrl, size) : null;
+    if (resizedFull)
+        return resolveUrl(resizedFull);
+    if (size <= 600) {
+        return resolveUrl(artwork.thumbnailUrl ?? artwork.imageUrl);
+    }
+    return resolveUrl(artwork.imageUrl ?? artwork.thumbnailUrl);
+}
+/** Fetch an image and return it as a base64 MCP image content block, or null. */
+export async function fetchImageContent(url) {
+    const resolved = resolveUrl(url);
+    if (!resolved)
+        return null;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), IMAGE_TIMEOUT_MS);
+    try {
+        const response = await fetch(resolved, {
+            headers: { "User-Agent": USER_AGENT },
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return null;
+        const mimeType = (response.headers.get("content-type") ?? "")
+            .split(";")[0]
+            ?.trim()
+            .toLowerCase();
+        if (!mimeType || !SUPPORTED_IMAGE_TYPES.has(mimeType))
+            return null;
+        // Reject obviously oversized bodies up front…
+        const declaredLength = Number(response.headers.get("content-length"));
+        if (Number.isFinite(declaredLength) && declaredLength > MAX_IMAGE_BYTES) {
+            return null;
+        }
+        // …then stream with a hard byte cap so a lying/missing content-length can't
+        // make us buffer an unbounded body into memory.
+        const reader = response.body?.getReader();
+        if (!reader)
+            return null;
+        const chunks = [];
+        let total = 0;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value)
+                continue;
+            total += value.byteLength;
+            if (total > MAX_IMAGE_BYTES) {
+                controller.abort();
+                return null;
+            }
+            chunks.push(value);
+        }
+        if (total === 0)
+            return null;
+        const buffer = Buffer.concat(chunks, total);
+        return { type: "image", data: buffer.toString("base64"), mimeType };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/** Convenience: fetch the best display image for an artwork as a content block. */
+export async function artworkImageContent(artwork, size) {
+    return fetchImageContent(bestDisplayUrl(artwork, size));
+}

package/dist/index.js

@@ -0,0 +1,551 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { platform } from "node:process";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { ApiError, API_BASE, findSimilar, getArtwork, getSuggestions, searchArtworks, sourceLabel, } from "./api.js";
+import { renderBoardHtml } from "./board-html.js";
+import { addArtworksToBoard, boardsExportDir, createBoard, deleteBoard, findBoard, loadBoards, removeItemsFromBoard, saveBoards, withBoards, } from "./boards.js";
+import { artworkImageContent } from "./images.js";
+const VERSION = "0.1.0";
+function text(value) {
+    return { type: "text", text: value };
+}
+function ok(content) {
+    return { content };
+}
+function fail(message) {
+    return { content: [text(message)], isError: true };
+}
+/** Wrap a handler so API/network errors become friendly tool errors, not crashes. */
+async function guard(run) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        if (error instanceof ApiError) {
+            return fail(`EveryMuseum API error: ${error.message}`);
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return fail(`Something went wrong: ${message}`);
+    }
+}
+function captionLine(art, index) {
+    const title = art.title?.trim() || "Untitled";
+    const artist = art.artist?.trim() || "Unknown artist";
+    const date = art.dateDisplay?.trim() || "n.d.";
+    const label = sourceLabel(art.source);
+    const license = art.license?.trim();
+    const tail = license ? ` · ${license}` : "";
+    return `${index}. "${title}" — ${artist} (${date}) · ${label}${tail}\n   id: ${art.id}`;
+}
+/** Build a captioned gallery: one text line per item, each followed by its image. */
+async function galleryContent(items, options) {
+    const start = options.startIndex ?? 1;
+    const images = options.includeImages
+        ? await Promise.all(items.map((art) => artworkImageContent(art, options.imageSize)))
+        : items.map(() => null);
+    const content = [];
+    items.forEach((art, i) => {
+        content.push(text(captionLine(art, start + i)));
+        const image = images[i];
+        if (image)
+            content.push(image);
+    });
+    return content;
+}
+function boardItemCaption(item, index) {
+    return captionLine({
+        id: item.id,
+        title: item.title,
+        artist: item.artist,
+        dateDisplay: item.dateDisplay,
+        source: item.source,
+        license: item.license,
+    }, index);
+}
+function boardSummaryLine(board) {
+    const count = board.items.length;
+    const desc = board.description ? ` — ${board.description}` : "";
+    return `• ${board.name} (slug: ${board.slug}, ${count} ${count === 1 ? "work" : "works"})${desc}`;
+}
+const server = new McpServer({ name: "everymuseum", version: VERSION }, {
+    instructions: [
+        "EveryMuseum is a searchable archive of open-access artworks aggregated from",
+        "museums worldwide (The Met, Rijksmuseum, Art Institute of Chicago, V&A, Getty,",
+        "Smithsonian, Harvard, Cleveland, and more).",
+        "",
+        "Use these tools to pull up images conversationally, learn about specific works,",
+        "discover related pieces, and curate persistent local 'boards' (mood boards /",
+        "reading lists) that can be exported to a shareable HTML gallery.",
+        "",
+        "Workflow tips: search_artworks → get_artwork (deep detail) → find_similar",
+        "(go deeper) → create_board / add_to_board (collect) → export_board (share).",
+        "Every artwork has a stable `id`; pass it to get_artwork, find_similar, and",
+        "add_to_board. Images are real artwork reproductions; always attribute the",
+        "source institution and respect the stated license.",
+    ].join("\n"),
+});
+// ─── Discovery & images ──────────────────────────────────────────────────────
+server.registerTool("search_artworks", {
+    title: "Search the EveryMuseum archive",
+    description: "Search open-access museum artworks by free text (artist, title, culture, " +
+        "medium, period, museum name, or theme — e.g. 'hokusai wave', 'art nouveau " +
+        "poster', 'egyptian bronze'). Returns captioned results with images so they " +
+        "can be shown directly in the conversation. Each result includes a stable id " +
+        "for use with get_artwork, find_similar, and add_to_board.",
+    inputSchema: {
+        query: z
+            .string()
+            .min(2)
+            .max(120)
+            .describe("Free-text search query (2–120 characters)."),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(24)
+            .optional()
+            .describe("How many works to return (default 6, max 24)."),
+        offset: z
+            .number()
+            .int()
+            .min(0)
+            .max(10000)
+            .optional()
+            .describe("Skip this many results for paging through more (default 0)."),
+        includeImages: z
+            .boolean()
+            .optional()
+            .describe("Return artwork images, not just text (default true)."),
+        imageSize: z
+            .number()
+            .int()
+            .min(200)
+            .max(2000)
+            .optional()
+            .describe("Long-edge pixel size for result images (default 512)."),
+    },
+    annotations: { readOnlyHint: true, openWorldHint: true },
+}, async (args) => guard(async () => {
+    const limit = args.limit ?? 6;
+    const includeImages = args.includeImages ?? true;
+    const imageSize = args.imageSize ?? 512;
+    const result = await searchArtworks(args.query, {
+        limit,
+        offset: args.offset ?? 0,
+    });
+    if (result.items.length === 0) {
+        return ok([
+            text(`No artworks matched "${args.query}". Try a broader term, an artist, ` +
+                `a culture, or call suggest_searches for ideas.`),
+        ]);
+    }
+    const totalNote = result.total != null
+        ? ` of ~${result.total.toLocaleString()} matching works`
+        : "";
+    const offset = args.offset ?? 0;
+    const moreNote = result.total != null && offset + result.items.length < result.total
+        ? ` Call again with offset: ${offset + result.items.length} for more.`
+        : "";
+    const header = text(`Showing ${result.items.length} result${result.items.length === 1 ? "" : "s"}` +
+        `${totalNote} for "${args.query}".${moreNote}`);
+    const gallery = await galleryContent(result.items, {
+        includeImages,
+        imageSize,
+        startIndex: offset + 1,
+    });
+    return ok([header, ...gallery]);
+}));
+server.registerTool("get_artwork", {
+    title: "Get full detail for one artwork",
+    description: "Fetch complete metadata for a single artwork by id — description, medium, " +
+        "dimensions, culture, department, classification, tags, license, and a link " +
+        "to the source record — plus a high-resolution image. Use this to learn " +
+        "about or discuss a specific work in depth.",
+    inputSchema: {
+        id: z.string().min(1).describe("The artwork id (from a search result)."),
+        includeImage: z
+            .boolean()
+            .optional()
+            .describe("Include a high-resolution image (default true)."),
+        imageSize: z
+            .number()
+            .int()
+            .min(400)
+            .max(3000)
+            .optional()
+            .describe("Long-edge pixel size for the image (default 1200)."),
+    },
+    annotations: { readOnlyHint: true, openWorldHint: true },
+}, async (args) => guard(async () => {
+    const art = await getArtwork(args.id);
+    const includeImage = args.includeImage ?? true;
+    const imageSize = args.imageSize ?? 1200;
+    const lines = [];
+    lines.push(`# ${art.title?.trim() || "Untitled"}`);
+    const facts = [
+        ["Artist", art.artist],
+        ["Date", art.dateDisplay],
+        ["Medium", art.medium],
+        ["Dimensions", art.dimensions],
+        ["Culture", art.culture],
+        ["Department", art.department],
+        ["Classification", art.classification],
+        ["Collection", sourceLabel(art.source)],
+        ["License", art.license],
+    ];
+    for (const [key, value] of facts) {
+        if (value && value.trim())
+            lines.push(`**${key}:** ${value.trim()}`);
+    }
+    if (art.description?.trim()) {
+        lines.push("", art.description.trim());
+    }
+    if (art.tags.length) {
+        lines.push("", `**Tags:** ${art.tags.slice(0, 20).join(", ")}`);
+    }
+    if (art.sourceUrl)
+        lines.push("", `Source record: ${art.sourceUrl}`);
+    lines.push("", `id: ${art.id}`);
+    lines.push("Next: find_similar to explore related works, or add_to_board to save it.");
+    const content = [text(lines.join("\n"))];
+    if (includeImage) {
+        const image = await artworkImageContent(art, imageSize);
+        if (image)
+            content.push(image);
+        else
+            content.push(text("(No displayable image is available for this work.)"));
+    }
+    return ok(content);
+}));
+server.registerTool("find_similar", {
+    title: "Find similar artworks",
+    description: "Given an artwork id, return works the archive considers related by shared " +
+        "tags, artist, culture, medium, department, or classification. Great for " +
+        "going deeper down a visual or thematic thread. Returns captioned images.",
+    inputSchema: {
+        id: z.string().min(1).describe("The artwork id to find neighbors for."),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(24)
+            .optional()
+            .describe("How many similar works to return (default 8, max 24)."),
+        includeImages: z
+            .boolean()
+            .optional()
+            .describe("Return images, not just text (default true)."),
+        imageSize: z
+            .number()
+            .int()
+            .min(200)
+            .max(2000)
+            .optional()
+            .describe("Long-edge pixel size for images (default 512)."),
+    },
+    annotations: { readOnlyHint: true, openWorldHint: true },
+}, async (args) => guard(async () => {
+    const limit = args.limit ?? 8;
+    const items = (await findSimilar(args.id)).slice(0, limit);
+    if (items.length === 0) {
+        return ok([
+            text(`No similar works found for id "${args.id}". The id may be invalid, ` +
+                `or the work has little metadata to match on.`),
+        ]);
+    }
+    const gallery = await galleryContent(items, {
+        includeImages: args.includeImages ?? true,
+        imageSize: args.imageSize ?? 512,
+    });
+    return ok([
+        text(`${items.length} works related to id ${args.id}:`),
+        ...gallery,
+    ]);
+}));
+server.registerTool("suggest_searches", {
+    title: "Suggest things to explore",
+    description: "Return a curated list of popular search terms drawn from the archive's top " +
+        "artists, cultures, collections, media, and source museums. Use when the " +
+        "user is unsure what to look for, then feed a term to search_artworks.",
+    inputSchema: {
+        limit: z
+            .number()
+            .int()
+            .min(5)
+            .max(160)
+            .optional()
+            .describe("How many suggestions to return (default 40)."),
+    },
+    annotations: { readOnlyHint: true, openWorldHint: true },
+}, async (args) => guard(async () => {
+    const limit = args.limit ?? 40;
+    const suggestions = (await getSuggestions()).slice(0, limit);
+    if (suggestions.length === 0) {
+        return ok([text("No suggestions are available right now.")]);
+    }
+    return ok([
+        text(`Try searching for any of these (pass one to search_artworks):\n\n` +
+            suggestions.map((value) => `• ${value}`).join("\n")),
+    ]);
+}));
+// ─── Boards ──────────────────────────────────────────────────────────────────
+server.registerTool("list_boards", {
+    title: "List saved boards",
+    description: "List every saved board with its name, slug, and number of works. Boards are " +
+        "stored locally on this machine and persist across conversations.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true },
+}, async () => guard(async () => {
+    const boards = await loadBoards();
+    if (boards.length === 0) {
+        return ok([
+            text("You have no boards yet. Create one with create_board."),
+        ]);
+    }
+    return ok([
+        text(`You have ${boards.length} board${boards.length === 1 ? "" : "s"}:\n\n` +
+            boards.map(boardSummaryLine).join("\n")),
+    ]);
+}));
+server.registerTool("create_board", {
+    title: "Create a board",
+    description: "Create a new board (a saved collection / mood board) to group artworks. " +
+        "Returns the board's slug; use it (or the name) with add_to_board.",
+    inputSchema: {
+        name: z.string().min(1).max(120).describe("A name for the board."),
+        description: z
+            .string()
+            .max(500)
+            .optional()
+            .describe("Optional one-line description of the board's theme."),
+    },
+    annotations: { readOnlyHint: false },
+}, async (args) => guard(() => withBoards(async (boards) => {
+    const board = createBoard(boards, args.name, args.description ?? null);
+    await saveBoards(boards);
+    return ok([
+        text(`Created board "${board.name}" (slug: ${board.slug}).\n` +
+            `Add works with add_to_board using board "${board.slug}" and artwork ids.`),
+    ]);
+})));
+server.registerTool("add_to_board", {
+    title: "Add artworks to a board",
+    description: "Add one or more artworks (by id) to a board, identified by its slug, name, " +
+        "or id. Stores a snapshot of each work so the board renders even if the " +
+        "archive changes. Skips ids already on the board.",
+    inputSchema: {
+        board: z
+            .string()
+            .min(1)
+            .describe("Board slug, name, or id to add to."),
+        artworkIds: z
+            .array(z.string().min(1))
+            .min(1)
+            .max(100)
+            .describe("Artwork ids to add (from search/get/similar results)."),
+    },
+    annotations: { readOnlyHint: false },
+}, async (args) => guard(async () => {
+    // Fetch artwork snapshots outside the board lock (network I/O), then take
+    // the lock only for the quick read-modify-write.
+    const unique = Array.from(new Set(args.artworkIds));
+    const fetched = await Promise.all(unique.map(async (id) => {
+        try {
+            return await getArtwork(id);
+        }
+        catch {
+            return null;
+        }
+    }));
+    const found = fetched.filter((art) => art !== null);
+    const notFound = unique.filter((id) => !found.some((art) => art.id === id));
+    return withBoards(async (boards) => {
+        const board = findBoard(boards, args.board);
+        if (!board) {
+            return fail(`No board matches "${args.board}". Use list_boards to see boards, or ` +
+                `create_board to make one.`);
+        }
+        const added = addArtworksToBoard(board, found);
+        const skipped = found.length - added;
+        await saveBoards(boards);
+        const parts = [
+            `Added ${added} work${added === 1 ? "" : "s"} to "${board.name}" ` +
+                `(now ${board.items.length} total).`,
+        ];
+        if (skipped > 0)
+            parts.push(`${skipped} already on the board.`);
+        if (notFound.length > 0) {
+            parts.push(`Could not find ${notFound.length}: ${notFound.join(", ")}.`);
+        }
+        parts.push(`Use export_board "${board.slug}" to render it.`);
+        return ok([text(parts.join(" "))]);
+    });
+}));
+server.registerTool("view_board", {
+    title: "View a board's contents",
+    description: "Show the works on a board with captioned images, identified by slug, name, " +
+        "or id. Persisted snapshot images are used, so this works without re-querying.",
+    inputSchema: {
+        board: z.string().min(1).describe("Board slug, name, or id to view."),
+        includeImages: z
+            .boolean()
+            .optional()
+            .describe("Show images, not just text (default true)."),
+        imageSize: z
+            .number()
+            .int()
+            .min(200)
+            .max(2000)
+            .optional()
+            .describe("Long-edge pixel size for images (default 512)."),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(40)
+            .optional()
+            .describe("Max works to show images for (default 24)."),
+    },
+    annotations: { readOnlyHint: true, openWorldHint: true },
+}, async (args) => guard(async () => {
+    const boards = await loadBoards();
+    const board = findBoard(boards, args.board);
+    if (!board)
+        return fail(`No board matches "${args.board}".`);
+    if (board.items.length === 0) {
+        return ok([
+            text(`"${board.name}" is empty. Add works with add_to_board.`),
+        ]);
+    }
+    const includeImages = args.includeImages ?? true;
+    const imageSize = args.imageSize ?? 512;
+    const limit = args.limit ?? 24;
+    const shown = board.items.slice(0, limit);
+    // BoardItem carries iiifUrl/imageUrl/thumbnailUrl, satisfying ImageSource.
+    const images = includeImages
+        ? await Promise.all(shown.map((item) => artworkImageContent(item, imageSize)))
+        : shown.map(() => null);
+    const header = `"${board.name}" — ${board.items.length} work${board.items.length === 1 ? "" : "s"}` +
+        (board.description ? `\n${board.description}` : "") +
+        (board.items.length > shown.length
+            ? `\n(Showing the first ${shown.length}.)`
+            : "");
+    const content = [text(header)];
+    shown.forEach((item, i) => {
+        content.push(text(boardItemCaption(item, i + 1)));
+        const image = images[i];
+        if (image)
+            content.push(image);
+    });
+    return ok(content);
+}));
+server.registerTool("remove_from_board", {
+    title: "Remove artworks from a board",
+    description: "Remove one or more artworks (by id) from a board.",
+    inputSchema: {
+        board: z.string().min(1).describe("Board slug, name, or id."),
+        artworkIds: z
+            .array(z.string().min(1))
+            .min(1)
+            .max(100)
+            .describe("Artwork ids to remove from the board."),
+    },
+    annotations: { readOnlyHint: false },
+}, async (args) => guard(() => withBoards(async (boards) => {
+    const board = findBoard(boards, args.board);
+    if (!board)
+        return fail(`No board matches "${args.board}".`);
+    const removed = removeItemsFromBoard(board, args.artworkIds);
+    await saveBoards(boards);
+    return ok([
+        text(`Removed ${removed} work${removed === 1 ? "" : "s"} from "${board.name}" ` +
+            `(now ${board.items.length} total).`),
+    ]);
+})));
+server.registerTool("export_board", {
+    title: "Export a board to an HTML gallery",
+    description: "Render a board as a self-contained, shareable HTML gallery page (an editorial " +
+        "contact sheet with captions, attribution, and source links) and write it to " +
+        "disk. Optionally open it in the default browser. Returns the file path.",
+    inputSchema: {
+        board: z.string().min(1).describe("Board slug, name, or id to export."),
+        open: z
+            .boolean()
+            .optional()
+            .describe("Open the exported page in the default browser (default false)."),
+    },
+    annotations: { readOnlyHint: false, openWorldHint: true },
+}, async (args) => guard(async () => {
+    const boards = await loadBoards();
+    const board = findBoard(boards, args.board);
+    if (!board)
+        return fail(`No board matches "${args.board}".`);
+    const dir = boardsExportDir();
+    await mkdir(dir, { recursive: true });
+    const filePath = join(dir, `${board.slug}-${board.id}.html`);
+    await writeFile(filePath, renderBoardHtml(board), "utf8");
+    let openNote = "";
+    if (args.open) {
+        const opener = platform === "darwin"
+            ? "open"
+            : platform === "win32"
+                ? "cmd"
+                : "xdg-open";
+        const openerArgs = platform === "win32" ? ["/c", "start", "", filePath] : [filePath];
+        try {
+            const child = spawn(opener, openerArgs, {
+                detached: true,
+                stdio: "ignore",
+            });
+            child.unref();
+            openNote = " Opening it in your browser now.";
+        }
+        catch {
+            openNote = " (Could not auto-open it; open the file manually.)";
+        }
+    }
+    return ok([
+        text(`Exported "${board.name}" (${board.items.length} works) to:\n${filePath}${openNote}`),
+    ]);
+}));
+server.registerTool("delete_board", {
+    title: "Delete a board",
+    description: "Permanently delete a board and its saved items. Requires confirm: true. " +
+        "This does not delete any exported HTML files.",
+    inputSchema: {
+        board: z.string().min(1).describe("Board slug, name, or id to delete."),
+        confirm: z
+            .boolean()
+            .describe("Must be true to actually delete the board."),
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
+}, async (args) => guard(() => withBoards(async (boards) => {
+    const board = findBoard(boards, args.board);
+    if (!board)
+        return fail(`No board matches "${args.board}".`);
+    if (!args.confirm) {
+        return ok([
+            text(`This will permanently delete "${board.name}" (slug: ${board.slug}, ` +
+                `${board.items.length} works). Call again with confirm: true to proceed.`),
+        ]);
+    }
+    const remaining = deleteBoard(boards, board);
+    await saveBoards(remaining);
+    return ok([text(`Deleted board "${board.name}".`)]);
+})));
+// ─── Boot ──────────────────────────────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // All logging must go to stderr; stdout is reserved for the MCP protocol.
+    console.error(`everymuseum-mcp ${VERSION} ready — archive: ${API_BASE}`);
+}
+main().catch((error) => {
+    console.error("everymuseum-mcp failed to start:", error);
+    process.exit(1);
+});

package/dist/types.js

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