@jetpump/mcp 0.1.0-beta.1

package/README.md

@@ -0,0 +1,39 @@
+# @jetpump/mcp
+
+MCP server that ships the current directory to a live `*.jetpump.dev` URL in
+one command from Claude Code.
+
+> **Beta.** Test-mode billing only. Free tier allows 1 active deploy with a
+> 48-hour TTL. See https://jetpump.dev for tiers.
+
+## Install
+
+```bash
+claude mcp add @jetpump/mcp@beta
+```
+
+## Use
+
+In any project directory, ask Claude Code:
+
+```
+deploy this project
+```
+
+Jetpump detects your stack (Next.js, Vite, React, Node, Python, Docker, …),
+builds it, and serves it on a live URL under `*.jetpump.dev`.
+
+## Tools exposed
+
+- `deploy` — zip current directory, upload, build, deploy
+- `list_deploys` — list your active deploys
+- `teardown` — delete a deploy and free its subdomain
+
+## Auth
+
+First call prompts for an email address, sends a magic link via Resend, and
+stores a JWT locally.
+
+## License
+
+MIT

package/dist/handlers.js

@@ -0,0 +1,130 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { zipDirectory } from './zip.js';
+const API_URL = process.env.JETPUMP_API_URL;
+const SECRET = process.env.JETPUMP_SECRET;
+function headers(extra = {}) {
+    return {
+        'x-poc-secret': SECRET ?? '',
+        'content-type': 'application/json',
+        ...extra,
+    };
+}
+function assertConfigured() {
+    if (!API_URL || !SECRET) {
+        throw new Error('JETPUMP_API_URL and JETPUMP_SECRET must be set');
+    }
+}
+export async function handleDeploy(args) {
+    assertConfigured();
+    const dir = path.resolve(args.directory);
+    const zipPath = path.join(os.tmpdir(), `jetpump-${Date.now()}.zip`);
+    console.error(`[jetpump-mcp] deploy start dir=${dir}`);
+    let zipInfo;
+    try {
+        zipInfo = await zipDirectory(dir, zipPath);
+    }
+    catch (err) {
+        const msg = err.message;
+        console.error(`[jetpump-mcp] deploy failed at zip: ${msg}`);
+        throw new Error(`zip failed: ${msg}`);
+    }
+    const { size, fileCount } = zipInfo;
+    let presign;
+    try {
+        const res = await fetch(`${API_URL}/presign`, {
+            method: 'POST',
+            headers: headers(),
+            body: JSON.stringify({ size_bytes: size }),
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status} ${await res.text().catch(() => '')}`);
+        presign = (await res.json());
+    }
+    catch (err) {
+        const msg = err.message;
+        console.error(`[jetpump-mcp] deploy failed at presign: ${msg}`);
+        throw new Error(`presign failed: ${msg}`);
+    }
+    console.error(`[jetpump-mcp] presign ok deployment_id=${presign.deployment_id} files=${fileCount} zip=${size}`);
+    try {
+        const zipBuf = await fs.readFile(zipPath);
+        const uploadRes = await fetch(presign.upload_url, {
+            method: 'PUT',
+            headers: { 'content-type': 'application/zip' },
+            body: zipBuf,
+        });
+        if (!uploadRes.ok) {
+            throw new Error(`HTTP ${uploadRes.status} ${await uploadRes.text().catch(() => '')}`);
+        }
+    }
+    catch (err) {
+        const msg = err.message;
+        console.error(`[jetpump-mcp] deploy failed at upload: ${msg}`);
+        throw new Error(`upload failed: ${msg}`);
+    }
+    console.error(`[jetpump-mcp] upload ok deployment_id=${presign.deployment_id}`);
+    try {
+        const res = await fetch(`${API_URL}/deploy`, {
+            method: 'POST',
+            headers: headers(),
+            body: JSON.stringify({
+                deployment_id: presign.deployment_id,
+                object_path: presign.object_path,
+                project_name: path.basename(dir),
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`HTTP ${res.status} ${await res.text().catch(() => '')}`);
+        }
+    }
+    catch (err) {
+        const msg = err.message;
+        console.error(`[jetpump-mcp] deploy failed at trigger: ${msg}`);
+        throw new Error(`trigger failed: ${msg}`);
+    }
+    console.error(`[jetpump-mcp] build triggered deployment_id=${presign.deployment_id}`);
+    const final = await pollUntilReady(presign.deployment_id);
+    console.error(`[jetpump-mcp] deploy ${final.status} id=${final.deployment_id} url=${final.url ?? '-'}`);
+    return { content: [{ type: 'text', text: formatResult(final) }] };
+}
+export async function handleListDeploys() {
+    assertConfigured();
+    console.error('[jetpump-mcp] list_deploys');
+    const res = await fetch(`${API_URL}/deploys`, { headers: headers() }).then((r) => r.json());
+    return { content: [{ type: 'text', text: JSON.stringify(res.deploys, null, 2) }] };
+}
+export async function handleTeardown(args) {
+    assertConfigured();
+    console.error(`[jetpump-mcp] teardown id=${args.deployment_id}`);
+    const res = await fetch(`${API_URL}/deploy/${args.deployment_id}`, {
+        method: 'DELETE',
+        headers: headers(),
+    }).then((r) => r.json());
+    return { content: [{ type: 'text', text: JSON.stringify(res, null, 2) }] };
+}
+async function pollUntilReady(deploymentId) {
+    const deadline = Date.now() + 10 * 60 * 1000;
+    while (Date.now() < deadline) {
+        const res = (await fetch(`${API_URL}/deploy/${deploymentId}`, {
+            headers: headers(),
+        }).then((r) => r.json()));
+        if (res.status === 'ready' || res.status === 'failed')
+            return res;
+        await new Promise((r) => setTimeout(r, 5000));
+    }
+    throw new Error(`Deploy ${deploymentId} timed out`);
+}
+function formatResult(d) {
+    if (d.status === 'failed') {
+        return `Deploy ${d.deployment_id} failed: ${d.error ?? 'unknown error'}`;
+    }
+    const secs = Math.round((d.build_ms ?? 0) / 1000);
+    return [
+        `Live at ${d.url}`,
+        `  Stack: ${d.stack ?? 'unknown'}`,
+        `  Build: ${secs}s`,
+        `  ID:    ${d.deployment_id}`,
+    ].join('\n');
+}

package/dist/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import './logger.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { tools } from './tools.js';
+import { handleDeploy, handleListDeploys, handleTeardown } from './handlers.js';
+const server = new Server({ name: 'jetpump', version: '0.0.1' }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params;
+    switch (name) {
+        case 'deploy': return handleDeploy(args);
+        case 'list_deploys': return handleListDeploys();
+        case 'teardown': return handleTeardown(args);
+        default: throw new Error(`Unknown tool: ${name}`);
+    }
+});
+await server.connect(new StdioServerTransport());

package/dist/logger.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+// Persistent stderr log: tees every console.error line to ~/.jetpump/mcp.log
+// so that [jetpump-mcp] breadcrumbs survive a GUI-launched Claude Code (which
+// has no terminal to capture the MCP child's stderr). POC-grade: appends
+// forever, no rotation. MVP should cap size and rotate.
+const LOG_DIR = path.join(os.homedir(), '.jetpump');
+const LOG_FILE = path.join(LOG_DIR, 'mcp.log');
+let logStream = null;
+try {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+    logStream = fs.createWriteStream(LOG_FILE, { flags: 'a' });
+}
+catch {
+    // If the log file can't be opened, fall back to stderr-only.
+    logStream = null;
+}
+const origError = console.error.bind(console);
+console.error = (...args) => {
+    origError(...args);
+    if (!logStream)
+        return;
+    try {
+        const line = args
+            .map((a) => (typeof a === 'string' ? a : safeStringify(a)))
+            .join(' ');
+        logStream.write(`${new Date().toISOString()} ${line}\n`);
+    }
+    catch {
+        // swallow — we already wrote to real stderr
+    }
+};
+function safeStringify(v) {
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+console.error(`[jetpump-mcp] boot pid=${process.pid} node=${process.version}`);

package/dist/tools.js

@@ -0,0 +1,32 @@
+export const tools = [
+    {
+        name: 'deploy',
+        description: 'Zip a local directory and deploy it to Jetpump. Returns a live URL.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                directory: {
+                    type: 'string',
+                    description: 'Absolute path to the project directory to deploy',
+                },
+            },
+            required: ['directory'],
+        },
+    },
+    {
+        name: 'list_deploys',
+        description: 'List active Jetpump deployments.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'teardown',
+        description: 'Delete a Jetpump deployment by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                deployment_id: { type: 'string', description: 'Jetpump deployment ID (e.g. dep_a3b4c5d6)' },
+            },
+            required: ['deployment_id'],
+        },
+    },
+];

package/dist/zip.js

@@ -0,0 +1,184 @@
+import fs from 'node:fs/promises';
+import { createWriteStream } from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import archiver from 'archiver';
+// The `ignore` package has an awkward export shape (function+namespace) that
+// TypeScript's NodeNext resolution can't type-check cleanly. createRequire
+// sidesteps the import typing while still getting the correct runtime value.
+const require = createRequire(import.meta.url);
+const ignore = require('ignore');
+const ALWAYS_EXCLUDE = [
+    // VCS and editor
+    '.git',
+    '.hg',
+    '.svn',
+    '.idea',
+    '.vscode',
+    '.DS_Store',
+    '*.log',
+    // Node/JS build + cache
+    'node_modules',
+    'dist',
+    'build',
+    'out',
+    '.next',
+    '.nuxt',
+    '.svelte-kit',
+    '.turbo',
+    '.parcel-cache',
+    '.cache',
+    '.nyc_output',
+    'coverage',
+    // Python build + cache
+    '.venv',
+    'venv',
+    'env',
+    '__pycache__',
+    '.pytest_cache',
+    '.mypy_cache',
+    '.ruff_cache',
+    '.tox',
+    '.ipynb_checkpoints',
+    // ML / data caches (the SQViewer killer)
+    '.semantic-cache',
+    'models',
+    // Rust / Java / Go build
+    'target',
+    '.gradle',
+    '.m2',
+    // IaC
+    '.terraform',
+    '.vagrant',
+];
+// Hard ceiling on total source bytes that may enter the zip. Jetpump is a
+// deploy tool — projects larger than this almost always contain unintended
+// artifacts (ML weights, datasets, caches) and zipping them would OOM the
+// MCP server process and sever the stdio transport with JSON-RPC -32000.
+export const MAX_ZIP_SOURCE_BYTES = 500 * 1024 * 1024;
+export async function zipDirectory(sourceDir, outPath) {
+    const started = Date.now();
+    const ig = ignore().add(ALWAYS_EXCLUDE);
+    try {
+        const gitignore = await fs.readFile(path.join(sourceDir, '.gitignore'), 'utf8');
+        ig.add(gitignore);
+    }
+    catch {
+        // no .gitignore → only ALWAYS_EXCLUDE applies
+    }
+    console.error(`[jetpump-mcp] scan start dir=${sourceDir}`);
+    const scan = await walk(sourceDir, ig);
+    console.error(`[jetpump-mcp] scan done files=${scan.files.length} bytes=${scan.totalBytes} (${fmtBytes(scan.totalBytes)})`);
+    if (scan.totalBytes > MAX_ZIP_SOURCE_BYTES) {
+        const top = scan.topDirs
+            .slice(0, 5)
+            .map((d) => `    ${d.name}: ${fmtBytes(d.bytes)}`)
+            .join('\n');
+        const msg = `Refusing to zip ${fmtBytes(scan.totalBytes)} from ${sourceDir} — ` +
+            `exceeds the ${fmtBytes(MAX_ZIP_SOURCE_BYTES)} source-size limit.\n\n` +
+            `Largest included paths:\n${top}\n\n` +
+            `Add the heaviest directories to your project's .gitignore and retry. ` +
+            `Jetpump already ignores node_modules, .venv, .cache, .semantic-cache, models, ` +
+            `dist, build, .next, __pycache__, target, and common IDE/VCS directories by default.`;
+        console.error(`[jetpump-mcp] size guard tripped: ${fmtBytes(scan.totalBytes)}`);
+        throw new Error(msg);
+    }
+    console.error(`[jetpump-mcp] zip start out=${outPath}`);
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            fn();
+        };
+        const output = createWriteStream(outPath);
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        output.on('close', () => {
+            const ms = Date.now() - started;
+            const zipSize = archive.pointer();
+            console.error(`[jetpump-mcp] zip done in=${fmtBytes(scan.totalBytes)} out=${fmtBytes(zipSize)} ms=${ms}`);
+            settle(() => resolve({ size: zipSize, fileCount: scan.files.length, bytesIn: scan.totalBytes }));
+        });
+        output.on('error', (err) => {
+            console.error(`[jetpump-mcp] zip output error: ${err.message}`);
+            settle(() => reject(err));
+        });
+        archive.on('error', (err) => {
+            console.error(`[jetpump-mcp] zip archive error: ${err.message}`);
+            settle(() => reject(err));
+        });
+        archive.on('warning', (err) => {
+            if (err?.code === 'ENOENT') {
+                console.error(`[jetpump-mcp] zip skipping missing file: ${err.message}`);
+                return;
+            }
+            console.error(`[jetpump-mcp] zip warning: ${err?.message}`);
+            settle(() => reject(err));
+        });
+        archive.pipe(output);
+        for (const rel of scan.files) {
+            archive.file(path.join(sourceDir, rel), { name: rel });
+        }
+        archive.finalize().catch((err) => {
+            console.error(`[jetpump-mcp] zip finalize error: ${err?.message ?? err}`);
+            settle(() => reject(err));
+        });
+    });
+}
+async function walk(root, ig) {
+    const files = [];
+    const dirBytes = new Map();
+    let totalBytes = 0;
+    async function visit(current) {
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch (err) {
+            console.error(`[jetpump-mcp] readdir failed ${current}: ${err.message}`);
+            return;
+        }
+        for (const entry of entries) {
+            const abs = path.join(current, entry.name);
+            const rel = path.relative(root, abs);
+            if (!rel)
+                continue;
+            const relForIgnore = entry.isDirectory() ? `${rel}/` : rel;
+            if (ig.ignores(relForIgnore))
+                continue;
+            if (entry.isDirectory()) {
+                await visit(abs);
+            }
+            else if (entry.isFile()) {
+                let size = 0;
+                try {
+                    const stat = await fs.stat(abs);
+                    size = stat.size;
+                }
+                catch (err) {
+                    console.error(`[jetpump-mcp] stat failed ${abs}: ${err.message}`);
+                    continue;
+                }
+                files.push(rel);
+                totalBytes += size;
+                const topDir = rel.split(path.sep)[0];
+                dirBytes.set(topDir, (dirBytes.get(topDir) ?? 0) + size);
+            }
+        }
+    }
+    await visit(root);
+    const topDirs = [...dirBytes.entries()]
+        .map(([name, bytes]) => ({ name, bytes }))
+        .sort((a, b) => b.bytes - a.bytes);
+    return { files, totalBytes, topDirs };
+}
+function fmtBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    if (n < 1024 * 1024 * 1024)
+        return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(n / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@jetpump/mcp",
+  "version": "0.1.0-beta.1",
+  "description": "Jetpump MCP server — deploy the current directory from Claude Code.",
+  "homepage": "https://jetpump.dev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AJB93/jetpump.git",
+    "directory": "packages/mcp"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": { "jetpump-mcp": "dist/index.js" },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": { "node": ">=20" },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "archiver": "^7.0.1",
+    "ignore": "^6.0.2"
+  },
+  "devDependencies": {
+    "@types/archiver": "^6.0.3",
+    "@types/node": "^22.9.0",
+    "typescript": "^5.6.3"
+  }
+}