morselhub-mcp 1.1.0

package/mcp-server.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+// MORSELHUB_MCP_VERSION=1.0.0
+/**
+ * MorselHub MCP Server + Channel
+ *
+ * Connects Claude to MorselHub via local HTTP API.
+ * Pushes incoming messages (iMessage, RetroCode, webhooks) to Claude via Channel.
+ *
+ * As Channel (recommended):
+ *   claude --dangerously-load-development-channels server:morselhub
+ *
+ * As MCP server (tools only):
+ *   claude mcp add morselhub node ~/morselhub-mcp-server.js
+ */
+
+const http = require('http');
+const API_BASE = 'http://127.0.0.1:21590';
+
+// ── HTTP helpers ──────────────────────────────────────
+
+function apiGet(path) {
+  return new Promise((resolve, reject) => {
+    http.get(`${API_BASE}${path}`, (res) => {
+      let data = '';
+      res.on('data', (c) => data += c);
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch { resolve(data); } });
+    }).on('error', reject);
+  });
+}
+
+function apiPost(path, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const req = http.request(`${API_BASE}${path}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) },
+    }, (res) => {
+      let result = '';
+      res.on('data', (c) => result += c);
+      res.on('end', () => { try { resolve(JSON.parse(result)); } catch { resolve(result); } });
+    });
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+// ── MCP Tools ──────────────────────────────────────────
+
+// ── MCP Prompts ──────────────────────────────────────────
+
+const prompts = [
+  {
+    name: 'morselhub_instructions',
+    description: 'Instructions for how to handle MorselHub messages',
+  }
+];
+
+const SYSTEM_INSTRUCTIONS = `You are Claude, connected to MorselHub — a message hub that receives messages from iMessage, RetroCode, and webhooks.
+
+When you receive a channel notification with a message:
+1. Read the message content
+2. Respond helpfully using the morselhub_reply tool
+3. Set the destination to match the source (imessage, retrocode, hub, or webhook)
+4. If the source is "imessage", extract the recipient from the reply_to field (format: "imessage:address")
+5. Keep responses concise — they may be sent back via iMessage
+
+You can also:
+- Use morselhub_get_feed to see recent message history
+- Use morselhub_get_settings to check configuration
+- Use morselhub_send_imessage to proactively message someone
+
+Always respond to incoming messages. Don't just acknowledge — provide a helpful answer.`;
+
+// ── MCP Tools ──────────────────────────────────────────
+
+const tools = [
+  {
+    name: 'morselhub_get_feed',
+    description: 'Get all messages from the MorselHub feed (iMessage, RetroCode, webhooks).',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'morselhub_reply',
+    description: 'Send a reply back through MorselHub. The reply will be routed to the original source (iMessage, RetroCode, etc).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', description: 'Reply text' },
+        destination: { type: 'string', description: 'Where to send: "imessage", "retrocode", "webhook"' },
+        recipient: { type: 'string', description: 'Recipient address (phone/email for iMessage, or URL for webhook)' },
+      },
+      required: ['text', 'destination'],
+    },
+  },
+  {
+    name: 'morselhub_send_imessage',
+    description: 'Send an iMessage to a contact.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        to: { type: 'string', description: 'Recipient phone/email' },
+        text: { type: 'string', description: 'Message text' },
+      },
+      required: ['to', 'text'],
+    },
+  },
+  {
+    name: 'morselhub_get_settings',
+    description: 'Get MorselHub settings (contacts, sources, ports).',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'morselhub_health',
+    description: 'Check if MorselHub is running.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+];
+
+async function handleToolCall(name, args) {
+  switch (name) {
+    case 'morselhub_get_feed': {
+      const feed = await apiGet('/api/feed');
+      return { content: [{ type: 'text', text: JSON.stringify(feed, null, 2) }] };
+    }
+    case 'morselhub_reply': {
+      // Post reply to hub, which routes it to the destination
+      await apiPost('/api/message', {
+        source: 'claude',
+        sender: 'Claude',
+        text: args.text,
+        reply_to: args.destination + ':' + (args.recipient || ''),
+      });
+      return { content: [{ type: 'text', text: `Reply sent to ${args.destination}` }] };
+    }
+    case 'morselhub_send_imessage': {
+      await apiPost('/api/message', {
+        source: 'claude',
+        sender: 'Claude',
+        text: `[iMessage to ${args.to}] ${args.text}`,
+        reply_to: 'imessage:' + args.to,
+      });
+      return { content: [{ type: 'text', text: `iMessage queued for ${args.to}` }] };
+    }
+    case 'morselhub_get_settings': {
+      const settings = await apiGet('/api/settings');
+      return { content: [{ type: 'text', text: JSON.stringify(settings, null, 2) }] };
+    }
+    case 'morselhub_health': {
+      const health = await apiGet('/api/health');
+      return { content: [{ type: 'text', text: JSON.stringify(health) }] };
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+// ── Channel push ───────────────────────────────────────
+
+let channelEnabled = false;
+let lastSeenMsgId = 0;
+
+function sendNotification(method, params) {
+  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n');
+}
+
+function pushChannel(content, meta) {
+  if (!channelEnabled) return;
+  sendNotification('notifications/claude/channel', { content, meta: meta || {} });
+}
+
+function startEventStream() {
+  process.stderr.write('[channel] Connecting to MorselHub SSE push stream...\n');
+
+  http.get(`${API_BASE}/api/events`, (res) => {
+    process.stderr.write(`[channel] Connected to push stream (status ${res.statusCode})\n`);
+
+    let buffer = '';
+    res.on('data', (chunk) => {
+      buffer += chunk.toString();
+      // Parse SSE events
+      const parts = buffer.split('\n\n');
+      buffer = parts.pop() || '';
+
+      for (const part of parts) {
+        if (part.startsWith(': keepalive')) continue;
+        const dataLine = part.split('\n').find(l => l.startsWith('data: '));
+        if (!dataLine) continue;
+
+        try {
+          const msg = JSON.parse(dataLine.slice(6));
+          if (msg.source === 'claude' || msg.source === 'system') continue;
+          if (!msg.reply_to) {
+            process.stderr.write(`[push] Skipping non-actionable: ${msg.text?.substring(0,30)}\n`);
+            continue;
+          }
+
+          const label = msg.source === 'imessage' ? `iMessage from ${msg.sender}` :
+                        msg.source === 'retrocode' ? `RetroCode (${msg.sender})` :
+                        `${msg.source} (${msg.sender})`;
+          process.stderr.write(`[push] ${label}: ${msg.text}\n`);
+          pushChannel(
+            `MorselHub message from ${label}: "${msg.text}"\n\nPlease respond using the morselhub_reply tool. destination="${msg.source}", reply_to="${msg.reply_to}".`,
+            { source: msg.source, sender: msg.sender, id: msg.id, reply_to: msg.reply_to }
+          );
+        } catch (e) {
+          process.stderr.write(`[push] Parse error: ${e.message}\n`);
+        }
+      }
+    });
+
+    res.on('end', () => {
+      process.stderr.write('[channel] Push stream disconnected. Reconnecting in 3s...\n');
+      setTimeout(startEventStream, 3000);
+    });
+
+    res.on('error', () => {
+      process.stderr.write('[channel] Push stream error. Reconnecting in 3s...\n');
+      setTimeout(startEventStream, 3000);
+    });
+  }).on('error', () => {
+    process.stderr.write('[channel] Cannot connect to MorselHub. Retrying in 5s...\n');
+    setTimeout(startEventStream, 5000);
+  });
+
+  // Heartbeat every 15s
+  setInterval(() => apiPost('/api/heartbeat', {}).catch(() => {}), 15000);
+}
+
+// ── JSON-RPC ───────────────────────────────────────────
+
+let buffer = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+  buffer += chunk;
+  const lines = buffer.split('\n');
+  buffer = lines.pop() || '';
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try { handleMessage(JSON.parse(line)); } catch {}
+  }
+});
+
+function sendResponse(id, result) {
+  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
+}
+
+function sendError(id, code, message) {
+  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }) + '\n');
+}
+
+async function handleMessage(msg) {
+  const { id, method, params } = msg;
+  switch (method) {
+    case 'initialize':
+      sendResponse(id, {
+        protocolVersion: '2024-11-05',
+        capabilities: {
+          tools: {},
+          prompts: {},
+          experimental: { 'claude/channel': {} },
+        },
+        serverInfo: { name: 'morselhub', version: '1.0.0' },
+      });
+      break;
+    case 'notifications/initialized':
+      channelEnabled = true;
+      process.stderr.write('[channel] MorselHub channel active — connecting push stream\n');
+      // Push instructions to Claude on connect
+      setTimeout(() => {
+        pushChannel(
+          SYSTEM_INSTRUCTIONS + '\n\nMorselHub is now connected. Messages will be PUSHED to you in real-time. Waiting for messages from iMessage, RetroCode, and webhooks.',
+          { source: 'system', mode: 'instructions' }
+        );
+      }, 1000);
+      startEventStream();
+      break;
+    case 'prompts/list':
+      sendResponse(id, { prompts });
+      break;
+    case 'prompts/get':
+      if (params.name === 'morselhub_instructions') {
+        sendResponse(id, {
+          description: 'Instructions for handling MorselHub messages',
+          messages: [{ role: 'user', content: { type: 'text', text: SYSTEM_INSTRUCTIONS } }],
+        });
+      } else {
+        sendError(id, -32602, 'Unknown prompt');
+      }
+      break;
+    case 'tools/list':
+      sendResponse(id, { tools });
+      break;
+    case 'tools/call':
+      try {
+        const result = await handleToolCall(params.name, params.arguments || {});
+        sendResponse(id, result);
+      } catch (e) {
+        sendResponse(id, { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true });
+      }
+      break;
+    case 'ping':
+      sendResponse(id, {});
+      break;
+    default:
+      if (id) sendError(id, -32601, `Method not found: ${method}`);
+      break;
+  }
+}
+
+process.stdin.resume();
+process.stderr.write('MorselHub MCP server started (with Channel support)\n');

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "morselhub-mcp",
+  "version": "1.1.0",
+  "description": "MorselHub MCP server — connects Claude to iMessage, RetroCode, and webhooks via MorselHub",
+  "main": "mcp-server.js",
+  "bin": {
+    "morselhub-mcp": "mcp-server.js"
+  },
+  "scripts": {
+    "start": "node mcp-server.js"
+  },
+  "keywords": ["mcp", "morselhub", "imessage", "claude", "anthropic"],
+  "author": "senzall",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}