@jetpump/mcp 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/index.js

@@ -1,19 +1,49 @@
 #!/usr/bin/env node
+// Boot order matters:
+//   1. Sentry.init() as early as possible so unhandled errors during
+//      subsequent imports are still captured.
+//   2. logger stderr adapter.
+//   3. MCP server + transport.
+import { initSentryMcp, captureException, flushSentry } from './sentry.js';
+initSentryMcp();
 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: {} } });
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+const server = new Server({ name: 'jetpump', version: pkg.version }, { 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}`);
+    try {
+        switch (name) {
+            case 'deploy': return await handleDeploy(args);
+            case 'list_deploys': return await handleListDeploys();
+            case 'teardown': return await handleTeardown(args);
+            default: throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (err) {
+        // Report to Sentry with scrubbed context then rethrow so the
+        // MCP client still sees a tool error.
+        captureException(err, {
+            tool: name,
+            mcp_version: pkg.version,
+            // arguments deliberately NOT included — may contain user paths.
+            // Sentry's beforeSend scrubs anything that does make it through.
+        });
+        throw err;
     }
 });
+// Best-effort flush on graceful shutdown so in-flight events reach Sentry.
+for (const sig of ['SIGINT', 'SIGTERM']) {
+    process.on(sig, async () => {
+        await flushSentry(2000);
+        process.exit(0);
+    });
+}
 await server.connect(new StdioServerTransport());

package/dist/sentry.js

@@ -0,0 +1,112 @@
+// Sentry wiring for @jetpump/mcp — runs on the user's machine under
+// Claude Code / Cursor / Windsurf. Every tool invocation is wrapped so
+// any crash in deploy/list/teardown lands in the jetpump-mcp Sentry
+// inbox with the MCP package version as the release tag.
+//
+// The DSN is baked into the published source because Sentry DSNs are
+// designed to be public ingestion keys (they allow writes, not reads).
+// Override via JETPUMP_MCP_SENTRY_DSN for testing or if you fork the
+// package. Setting the env var to the empty string disables Sentry
+// entirely.
+//
+// beforeSend strips anything that smells like a JWT or an absolute
+// filesystem path so user source code filenames don't leak into our
+// inbox. It's a light scrubber — a paranoid user can set
+// JETPUMP_MCP_SENTRY_DSN="" to turn Sentry off.
+import * as Sentry from '@sentry/node';
+import { createRequire } from 'node:module';
+const BAKED_DSN = 'https://6dcaba3d4523d78fe23bd2cd45083724@o4511219499859968.ingest.us.sentry.io/4511219510542336';
+let initialised = false;
+function pkgVersion() {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkg = require('../package.json');
+        return pkg.version || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function scrub(obj) {
+    if (obj == null)
+        return obj;
+    if (typeof obj === 'string') {
+        // Strip bearer/JWT-ish blobs
+        return obj
+            .replace(/(Bearer\s+)[A-Za-z0-9._~\-+/=]{20,}/g, '$1<redacted>')
+            .replace(/eyJ[A-Za-z0-9._\-]{30,}/g, '<redacted-jwt>')
+            // Drop the user portion of absolute home paths
+            .replace(/\/Users\/[^/]+/g, '/Users/<user>')
+            .replace(/\/home\/[^/]+/g, '/home/<user>');
+    }
+    if (Array.isArray(obj))
+        return obj.map(scrub);
+    if (typeof obj === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+            if (/authorization|x-anon-token|jwt|password|secret/i.test(k)) {
+                out[k] = '<redacted>';
+            }
+            else {
+                out[k] = scrub(v);
+            }
+        }
+        return out;
+    }
+    return obj;
+}
+export function initSentryMcp() {
+    if (initialised)
+        return;
+    initialised = true;
+    const rawDsn = process.env.JETPUMP_MCP_SENTRY_DSN;
+    const dsn = rawDsn === undefined ? BAKED_DSN : rawDsn; // explicit empty string disables
+    if (!dsn)
+        return;
+    try {
+        Sentry.init({
+            dsn,
+            release: `@jetpump/mcp@${pkgVersion()}`,
+            environment: process.env.NODE_ENV || 'production',
+            tracesSampleRate: 0,
+            beforeSend(event) {
+                try {
+                    if (event.extra)
+                        event.extra = scrub(event.extra);
+                    if (event.tags)
+                        event.tags = scrub(event.tags);
+                    if (event.breadcrumbs) {
+                        event.breadcrumbs = event.breadcrumbs.map((b) => ({
+                            ...b,
+                            data: scrub(b.data),
+                            message: typeof b.message === 'string' ? scrub(b.message) : b.message,
+                        }));
+                    }
+                }
+                catch {
+                    // If scrubbing itself throws, drop the event defensively.
+                    return null;
+                }
+                return event;
+            },
+        });
+    }
+    catch (err) {
+        // Never fail the MCP startup because of Sentry.
+        process.stderr.write(`[jetpump-mcp] sentry init failed: ${err.message}\n`);
+    }
+}
+export function captureException(err, extra = {}) {
+    try {
+        Sentry.captureException(err, { extra: scrub(extra) });
+    }
+    catch {
+        // swallow — Sentry transport is best-effort
+    }
+}
+export async function flushSentry(timeoutMs = 2000) {
+    try {
+        await Sentry.flush(timeoutMs);
+    }
+    catch { /* ignore */ }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jetpump/mcp",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.3",
   "description": "Jetpump MCP server — deploy the current directory from Claude Code.",
   "homepage": "https://jetpump.dev",
   "license": "MIT",
@@ -24,6 +24,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
+    "@sentry/node": "^8.47.0",
     "archiver": "^7.0.1",
     "ignore": "^6.0.2"
   },