artifact-hub-mcp 1.0.0

package/dist/client.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Artifact Hub MCP Client — standalone stdio server.
+ *
+ * Proxies MCP tool calls to the Artifact Hub REST API over HTTP.
+ * Reads local files from disk (fileLocalPath) and uploads as multipart — works
+ * even when the API server is remote/hosted.
+ *
+ * Environment variables:
+ *   ARTIFACT_HUB_URL      Base URL of the API (default: http://localhost:3000)
+ *   ARTIFACT_HUB_API_KEY  API key (default: changeme-local-dev)
+ *   MCP_AUTHOR            Default feedback author (default: MCP User)
+ *
+ * Claude Desktop config (local dev):
+ * {
+ *   "mcpServers": {
+ *     "artifact-hub": {
+ *       "command": "/path/to/mcp/node_modules/.bin/ts-node",
+ *       "args": ["--project", "/path/to/mcp/tsconfig.json", "/path/to/mcp/client.ts"],
+ *       "env": {
+ *         "ARTIFACT_HUB_URL": "http://localhost:3000",
+ *         "ARTIFACT_HUB_API_KEY": "changeme-local-dev",
+ *         "MCP_AUTHOR": "Your Name"
+ *       }
+ *     }
+ *   }
+ * }
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+// ─── Config ──────────────────────────────────────────────────────────────────
+const BASE_URL = (process.env['ARTIFACT_HUB_URL'] ?? 'http://localhost:3000').replace(/\/$/, '');
+const API_KEY = process.env['ARTIFACT_HUB_API_KEY'] ?? process.env['API_KEY'] ?? 'changeme-local-dev';
+const DEFAULT_AUTHOR = process.env['MCP_AUTHOR'] ?? 'MCP User';
+const MIME_BY_EXT = {
+    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
+    '.gif': 'image/gif', '.webp': 'image/webp',
+    '.pdf': 'application/pdf',
+    '.html': 'text/html', '.htm': 'text/html',
+};
+// ─── HTTP helpers ─────────────────────────────────────────────────────────────
+const authHeader = { Authorization: `Bearer ${API_KEY}` };
+async function apiGet(path) {
+    const resp = await fetch(`${BASE_URL}${path}`, { headers: authHeader });
+    if (!resp.ok)
+        throw new Error(`${resp.status} ${await resp.text()}`);
+    return resp.json();
+}
+async function apiPost(path, body) {
+    const resp = await fetch(`${BASE_URL}${path}`, {
+        method: 'POST',
+        headers: { ...authHeader, 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!resp.ok)
+        throw new Error(`${resp.status} ${await resp.text()}`);
+    return resp.json();
+}
+async function uploadMultipart(artifactPath, fileBuffer, filename, mimetype, title, description, tags) {
+    const form = new FormData();
+    form.append('file', new Blob([new Uint8Array(fileBuffer)], { type: mimetype }), filename);
+    form.append('title', title);
+    if (description)
+        form.append('description', description);
+    if (tags && tags.length > 0)
+        form.append('tags', JSON.stringify(tags));
+    const resp = await fetch(`${BASE_URL}/artifacts/${artifactPath}`, {
+        method: 'POST',
+        headers: authHeader, // no Content-Type — fetch sets it with boundary automatically
+        body: form,
+    });
+    if (!resp.ok)
+        throw new Error(`${resp.status} ${await resp.text()}`);
+    return resp.json();
+}
+// ─── MCP Server ───────────────────────────────────────────────────────────────
+const server = new index_js_1.Server({ name: 'artifact-hub', version: '1.0.0' }, { capabilities: { tools: {} } });
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: 'get_catalog',
+            description: 'Returns the full artifact catalog as YAML: all folders (with allTags, artifactCount) ' +
+                'and all artifacts (title, description, tags, path). Call this first.',
+            inputSchema: { type: 'object', properties: {} },
+        },
+        {
+            name: 'search_artifacts',
+            description: 'Search artifacts and folders by text. Matches titles, descriptions, tags, paths.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Search text' },
+                    limit: { type: 'number', description: 'Max results (default 20)' },
+                },
+                required: ['query'],
+            },
+        },
+        {
+            name: 'browse_folder',
+            description: 'List subfolders and direct artifacts in a folder. Use path="" for root.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Folder path, or "" for root' },
+                    cursor: { type: 'string', description: 'Pagination cursor from a previous call' },
+                },
+                required: ['path'],
+            },
+        },
+        {
+            name: 'get_artifact',
+            description: 'Get metadata, all feedback comments, and a 1-hour presigned view URL.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Full artifact path, e.g. "designs/hero-v2.png"' },
+                },
+                required: ['path'],
+            },
+        },
+        {
+            name: 'request_upload_url',
+            description: 'Request a presigned upload URL for a file attached to the chat (path is /mnt/user-data/uploads/...). ' +
+                'Use this when the user drags/attaches a file into the chat. ' +
+                'Returns an uploadUrl (valid 30 seconds) and a ready-to-run curl command. ' +
+                'After calling this, immediately run the curl command to upload the file — do NOT read the file or use fileBase64.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Target storage path including filename, e.g. "designs/hero.png"' },
+                    title: { type: 'string', description: 'Human-readable title' },
+                    description: { type: 'string', description: 'Optional description' },
+                    tags: { type: 'array', items: { type: 'string' }, description: 'Optional tags' },
+                    contentType: { type: 'string', description: 'MIME type — auto-detected from extension if omitted' },
+                    fileLocalPath: { type: 'string', description: 'The /mnt/user-data/... path of the file in the chat sandbox' },
+                },
+                required: ['path', 'title', 'fileLocalPath'],
+            },
+        },
+        {
+            name: 'publish_artifact',
+            description: 'Upload a new artifact from an explicit filesystem path (e.g. /Users/me/Downloads/file.pdf). ' +
+                'Use fileLocalPath — pass the path string only, do NOT read bytes. ' +
+                'If the file was dragged/attached into the chat (path is /mnt/user-data/...) use request_upload_url instead. ' +
+                'Read and analyze the file yourself first to generate title, description, tags, and path.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Target path including filename, e.g. "designs/sprint12/hero.png"' },
+                    title: { type: 'string', description: 'Human-readable title' },
+                    description: { type: 'string', description: 'Optional description' },
+                    tags: { type: 'array', items: { type: 'string' }, description: 'Optional tags' },
+                    fileLocalPath: { type: 'string', description: 'Absolute filesystem path — use when user provided an explicit path' },
+                    fileUrl: { type: 'string', description: 'Public HTTP URL to download from' },
+                    fileBase64: { type: 'string', description: 'Base64 content — use for small files (≤5 MB) uploaded into the chat' },
+                    contentType: { type: 'string', description: 'MIME type — auto-detected from extension' },
+                },
+                required: ['path', 'title'],
+            },
+        },
+        {
+            name: 'add_feedback',
+            description: `Add a feedback comment. Author defaults to "${DEFAULT_AUTHOR}" (set MCP_AUTHOR env to change).`,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Artifact path' },
+                    author: { type: 'string', description: `Commenter name (default: "${DEFAULT_AUTHOR}")` },
+                    text: { type: 'string', description: 'Comment text' },
+                },
+                required: ['path', 'text'],
+            },
+        },
+        {
+            name: 'share_artifact',
+            description: 'Generate a time-limited presigned download URL.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Artifact path' },
+                    ttlHours: { type: 'number', description: 'Validity in hours (default 24, max 168)' },
+                },
+                required: ['path'],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
+    const { name, arguments: args = {} } = req.params;
+    try {
+        switch (name) {
+            case 'get_catalog': {
+                const data = await apiGet('/catalog');
+                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+            }
+            case 'search_artifacts': {
+                const limit = args['limit'] ?? 20;
+                const data = await apiGet(`/search?q=${encodeURIComponent(args['query'])}&limit=${limit}`);
+                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+            }
+            case 'browse_folder': {
+                const path = args['path'];
+                const cursor = args['cursor'];
+                const url = path ? `/browse/${path}` : '/browse';
+                const full = cursor ? `${url}?cursor=${encodeURIComponent(cursor)}` : url;
+                const data = await apiGet(full);
+                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+            }
+            case 'get_artifact': {
+                const path = args['path'];
+                const [detail, feedback] = await Promise.all([
+                    apiGet(`/artifacts/${path}`),
+                    apiGet(`/artifacts/${path}/feedback`).catch(() => []),
+                ]);
+                return { content: [{ type: 'text', text: JSON.stringify({ ...detail, feedback }, null, 2) }] };
+            }
+            case 'request_upload_url': {
+                const data = await apiPost('/upload/token', {
+                    path: args['path'],
+                    title: args['title'],
+                    description: args['description'],
+                    tags: args['tags'],
+                    contentType: args['contentType'],
+                });
+                const curlCmd = `curl -s -X POST '${data.uploadUrl}' -F 'file=@${args['fileLocalPath']}'`;
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                uploadUrl: data.uploadUrl,
+                                expiresIn: data.expiresIn,
+                                curlCommand: curlCmd,
+                                instruction: 'Run the curlCommand now to upload the file.',
+                            }, null, 2),
+                        }],
+                };
+            }
+            case 'publish_artifact': {
+                const targetPath = args['path'];
+                const filename = targetPath.split('/').pop() ?? 'file';
+                const explicit = args['contentType'];
+                let buffer;
+                let mimetype;
+                if (args['fileLocalPath']) {
+                    const localPath = args['fileLocalPath'];
+                    buffer = (0, fs_1.readFileSync)(localPath);
+                    const ext = (0, path_1.extname)(localPath).toLowerCase();
+                    mimetype = explicit ?? MIME_BY_EXT[ext] ?? 'application/octet-stream';
+                }
+                else if (args['fileUrl']) {
+                    const resp = await fetch(args['fileUrl']);
+                    if (!resp.ok)
+                        throw new Error(`Fetch failed: ${resp.status}`);
+                    buffer = Buffer.from(await resp.arrayBuffer());
+                    const ct = resp.headers.get('content-type');
+                    const ctPrimary = ct ? (ct.split(';')[0] ?? ct).trim() : undefined;
+                    mimetype = ctPrimary ?? explicit ?? 'application/octet-stream';
+                }
+                else if (args['fileBase64']) {
+                    buffer = Buffer.from(args['fileBase64'], 'base64');
+                    const ext = (0, path_1.extname)(filename).toLowerCase();
+                    mimetype = explicit ?? MIME_BY_EXT[ext] ?? 'application/octet-stream';
+                }
+                else {
+                    throw new Error('Provide fileLocalPath, fileUrl, or fileBase64');
+                }
+                const data = await uploadMultipart(targetPath, buffer, filename, mimetype, args['title'], args['description'], args['tags']);
+                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+            }
+            case 'add_feedback': {
+                const author = args['author'] ?? DEFAULT_AUTHOR;
+                const data = await apiPost(`/artifacts/${args['path']}/feedback`, {
+                    author,
+                    text: args['text'],
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+            }
+            case 'share_artifact': {
+                const ttlHours = Math.min(args['ttlHours'] ?? 24, 168);
+                const data = await apiPost(`/artifacts/${args['path']}/share`, {
+                    ttlSeconds: ttlHours * 3600,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify({ ...data, ttlHours }, null, 2) }] };
+            }
+            default:
+                return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+        }
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${String(err)}` }], isError: true };
+    }
+});
+// ─── Bootstrap ────────────────────────────────────────────────────────────────
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    transport.onclose = () => process.exit(0);
+}
+main().catch((err) => {
+    process.stderr.write(`[artifact-hub MCP] failed to start: ${String(err)}\n`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "artifact-hub-mcp",
+  "version": "1.0.0",
+  "description": "Artifact Hub MCP stdio client — proxies tool calls to the REST API",
+  "main": "dist/client.js",
+  "bin": {
+    "artifact-hub-mcp": "./dist/client.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "start": "ts-node --project tsconfig.json client.ts",
+    "build": "tsc --project tsconfig.json",
+    "type-check": "tsc --project tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}