marble-headed-mcp 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+import fs from 'fs/promises';
+import path from 'path';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+const DEFAULT_BASE_URL = 'http://localhost:5055';
+function resolveBaseUrl() {
+    const base = process.env.HEADED_SERVER_BASE_URL || DEFAULT_BASE_URL;
+    return base.replace(/\/+$/, '');
+}
+function buildUrl(pathname) {
+    return `${resolveBaseUrl()}${pathname}`;
+}
+async function postJson(pathname, payload) {
+    const response = await fetch(buildUrl(pathname), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload ?? {}),
+    });
+    const text = await response.text();
+    let json = null;
+    try {
+        json = JSON.parse(text);
+    }
+    catch (error) {
+        json = null;
+    }
+    return { status: response.status, ok: response.ok, text, json };
+}
+async function getText(pathname) {
+    const response = await fetch(buildUrl(pathname));
+    const text = await response.text();
+    return { status: response.status, ok: response.ok, text };
+}
+function inferExtensionFromMime(mimeType) {
+    if (!mimeType)
+        return null;
+    if (mimeType.includes('jpeg') || mimeType.includes('jpg'))
+        return 'jpg';
+    if (mimeType.includes('png'))
+        return 'png';
+    if (mimeType.includes('webp'))
+        return 'webp';
+    return null;
+}
+function inferExtensionFromUrl(inputUrl) {
+    try {
+        const parsed = new URL(inputUrl);
+        const ext = path.extname(parsed.pathname || '');
+        return ext ? ext.replace('.', '') : null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+async function saveImageFromUrl({ url, filename }) {
+    if (!url) {
+        return { ok: false, error: 'url is required.' };
+    }
+    const normalizedUrl = String(url).trim();
+    if (!normalizedUrl) {
+        return { ok: false, error: 'url must be non-empty.' };
+    }
+    if (typeof fetch !== 'function') {
+        return { ok: false, error: 'Global fetch is not available in this Node runtime.' };
+    }
+    const response = await fetch(normalizedUrl);
+    if (!response.ok) {
+        return { ok: false, error: `Failed to fetch image (${response.status}).` };
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    const contentType = response.headers.get('content-type') || '';
+    const extensionFromMime = inferExtensionFromMime(contentType);
+    const extensionFromUrl = inferExtensionFromUrl(normalizedUrl);
+    const safeName = filename ? path.basename(filename) : '';
+    const extension = extensionFromMime || (safeName.includes('.') ? safeName.split('.').pop() : null) || extensionFromUrl || 'jpg';
+    const baseName = safeName ? safeName.replace(/\.[^.]+$/, '') : `headed-${Date.now()}`;
+    const fileName = `${baseName}.${extension}`;
+    const targetPath = path.join('/tmp', fileName);
+    await fs.writeFile(targetPath, buffer);
+    return { ok: true, path: targetPath, bytes: buffer.length };
+}
+const TOOLS = [
+    {
+        name: 'headed_start_session',
+        description: 'Start a headed browser session (optionally with email + password for login).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                email: { type: 'string' },
+                password: { type: 'string' },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'headed_end_session',
+        description: 'End a headed browser session.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                browserSessionId: { type: 'number' },
+            },
+            required: ['browserSessionId'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'headed_navigate_to_project',
+        description: 'Navigate a headed session to /sims/{projectId}.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                browserSessionId: { type: 'number' },
+                projectId: { type: ['number', 'string'] },
+            },
+            required: ['browserSessionId', 'projectId'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'headed_send_msg',
+        description: 'Send a chat message in the headed session and capture screenshots (returns links).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                browserSessionId: { type: 'number' },
+                waitDuration: { type: 'number' },
+                screenshotInterval: { type: 'number' },
+                msg: { type: 'string' },
+            },
+            required: ['browserSessionId', 'waitDuration', 'screenshotInterval', 'msg'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'screenshots_preview',
+        description: 'Render screenshots HTML (accepts screenshots/screenshotUrls array or full response body).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                screenshots: { type: 'array', items: { type: 'string' } },
+                screenshotUrls: { type: 'array', items: { type: 'string' } },
+                response: { type: 'object' },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'screenshots_get_preview',
+        description: 'Fetch the preview HTML page for a stored screenshot set.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                previewId: { type: 'string' },
+            },
+            required: ['previewId'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'workflow_end_to_end_project_generation',
+        description: 'Run the server-side end-to-end project workflow (features → provision → boilerplate).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string' },
+                description: { type: 'string' },
+                technologies: { type: 'array', items: { type: 'string' } },
+                language: { type: 'string' },
+                planId: { type: ['string', 'number'] },
+                personalizationNotes: { type: 'string' },
+                email: { type: 'string' },
+                user_id: { type: 'string' },
+                show_scaffold: { type: 'boolean' },
+                show_checkpoints: { type: 'boolean' },
+                show_walkthrough: { type: 'boolean' },
+                onboarding_completed: { type: 'boolean' },
+                target_skills: { type: 'array', items: { type: 'string' } },
+                project_setup_complete: { type: 'boolean' },
+                boilerplate_setup_complete: { type: 'boolean' },
+                plan_id: { type: ['string', 'number'] },
+                plan_project_id: { type: ['string', 'number'] },
+                posthogDistinctId: { type: 'string' },
+                workflowRunName: { type: 'string' },
+            },
+            required: ['title', 'description', 'technologies'],
+            additionalProperties: true,
+        },
+    },
+    {
+        name: 'complete_project',
+        description: 'Run the server-side complete_project workflow (overwrites project files).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectId: { type: 'number' },
+            },
+            required: ['projectId'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'save_image_base64',
+        description: 'Download an image URL to /tmp and return the file path.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string' },
+                filename: { type: 'string' },
+            },
+            required: ['url'],
+            additionalProperties: false,
+        },
+    },
+];
+const server = new Server({
+    name: 'marble-headed-mcp',
+    version: '0.1.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case 'headed_start_session': {
+                const result = await postJson('/start_session', args);
+                return { content: [{ type: 'text', text: JSON.stringify(result.json || { status: result.status, body: result.text }, null, 2) }] };
+            }
+            case 'headed_end_session': {
+                const result = await postJson('/end_session', args);
+                return { content: [{ type: 'text', text: JSON.stringify(result.json || { status: result.status, body: result.text }, null, 2) }] };
+            }
+            case 'headed_navigate_to_project': {
+                const result = await postJson('/navigate_to_project', args);
+                return { content: [{ type: 'text', text: JSON.stringify(result.json || { status: result.status, body: result.text }, null, 2) }] };
+            }
+            case 'headed_send_msg': {
+                const result = await postJson('/send_msg_headed', args);
+                return { content: [{ type: 'text', text: JSON.stringify(result.json || { status: result.status, body: result.text }, null, 2) }] };
+            }
+            case 'screenshots_preview': {
+                const payload = args?.screenshots
+                    ? { screenshots: args.screenshots }
+                    : args?.screenshotUrls
+                        ? { screenshotUrls: args.screenshotUrls }
+                        : args?.response || args;
+                const result = await postJson('/preview_screenshots', payload);
+                return { content: [{ type: 'text', text: JSON.stringify({ status: result.status, ok: result.ok, html: result.text }, null, 2) }] };
+            }
+            case 'screenshots_get_preview': {
+                const previewId = args?.previewId;
+                const result = await getText(`/preview_screenshots/${encodeURIComponent(previewId)}`);
+                return { content: [{ type: 'text', text: JSON.stringify({ status: result.status, ok: result.ok, html: result.text }, null, 2) }] };
+            }
+            case 'workflow_end_to_end_project_generation': {
+                const result = await postJson('/end_to_end_project_generation', args);
+                return { content: [{ type: 'text', text: JSON.stringify(result.json || { status: result.status, body: result.text }, null, 2) }] };
+            }
+            case 'complete_project': {
+                const result = await postJson('/complete_project', args);
+                return { content: [{ type: 'text', text: JSON.stringify(result.json || { status: result.status, body: result.text }, null, 2) }] };
+            }
+            case 'save_image_base64': {
+                const saveResult = await saveImageFromUrl({
+                    url: args?.url,
+                    filename: args?.filename,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(saveResult, null, 2) }] };
+            }
+            default:
+                return { content: [{ type: 'text', text: `Unknown tool: ${name}` }] };
+        }
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: JSON.stringify({ ok: false, error: error?.message || String(error) }, null, 2) }] };
+    }
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "marble-headed-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Marble headed automation endpoints",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "marble-headed-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "marble",
+    "headed",
+    "playwright",
+    "workflow",
+    "model-context-protocol"
+  ],
+  "author": "Marble Team",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.1",
+    "typescript": "^5.7.2"
+  }
+}