@feedmob/user-activity-reporting 0.0.1

package/README.md

@@ -0,0 +1,78 @@
+# User Activity Reporting MCP
+
+MCP server for querying client contacts, Slack messages, and HubSpot tickets.
+
+## Features
+
+| Tool | Description |
+|------|-------------|
+| `get_all_client_contacts` | List all clients with team members |
+| `get_client_team_members` | Get team (AA, AM, AE, PM, PA, AO) for a client |
+| `get_clients_by_pod` | List clients in a POD team |
+| `get_clients_by_name` | Find clients by person name |
+| `get_user_slack_history` | Search Slack messages from a user |
+| `get_hubspot_tickets` | Query HubSpot tickets |
+| `get_hubspot_ticket_detail` | Get ticket details |
+| `get_hubspot_tickets_by_user` | Find tickets by owner |
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `FEEDMOB_API_BASE` | Yes | Feedmob Admin API URL (e.g., `https://admin.feedmob.com`) |
+| `FEEDMOB_KEY` | Yes | Feedmob API key |
+| `FEEDMOB_SECRET` | Yes | Feedmob API secret |
+| `SLACK_BOT_TOKEN` | No | Slack Bot token for message search |
+| `HUBSPOT_ACCESS_TOKEN` | No | HubSpot private app token |
+
+## Setup
+
+```bash
+cd src/user-activity-reporting
+npm install
+npm run build
+```
+
+## Development
+
+```bash
+npm run dev      # Run with hot reload
+npm run inspect  # Test tools interactively
+npm run build    # Compile to dist/
+```
+
+## MCP Configuration
+
+```json
+{
+  "mcpServers": {
+    "user-activity-reporting": {
+      "command": "npx",
+      "args": ["-y", "@feedmob/user-activity-reporting"],
+      "env": {
+        "FEEDMOB_API_BASE": "https://admin.feedmob.com",
+        "FEEDMOB_KEY": "your_key",
+        "FEEDMOB_SECRET": "your_secret",
+        "SLACK_BOT_TOKEN": "xoxb-xxx",
+        "HUBSPOT_ACCESS_TOKEN": "pat-xxx"
+      }
+    }
+  }
+}
+```
+
+## Usage Examples
+
+```
+# Get team for a client
+Tool: get_client_team_members
+Args: { "client_name": "Uber" }
+
+# Find clients by person
+Tool: get_clients_by_name
+Args: { "name": "John", "role": "am" }
+
+# Search Slack messages
+Tool: get_user_slack_history
+Args: { "user_name": "John", "query": "budget" }
+```

package/dist/api.js

@@ -0,0 +1,169 @@
+import jwt from 'jsonwebtoken';
+import dotenv from 'dotenv';
+dotenv.config();
+const API_BASE = process.env.FEEDMOB_API_BASE;
+const API_KEY = process.env.FEEDMOB_KEY;
+const API_SECRET = process.env.FEEDMOB_SECRET;
+if (!API_KEY || !API_SECRET) {
+    console.error("Error: FEEDMOB_KEY and FEEDMOB_SECRET must be set.");
+    process.exit(1);
+}
+function genToken() {
+    const exp = new Date();
+    exp.setDate(exp.getDate() + 7);
+    return jwt.sign({ key: API_KEY, expired_at: exp.toISOString().split('T')[0] }, API_SECRET, { algorithm: 'HS256' });
+}
+function buildUrl(path, params) {
+    const url = new URL(`${API_BASE}${path}`);
+    Object.entries(params).forEach(([k, v]) => url.searchParams.append(k, v));
+    return url.toString();
+}
+async function apiGet(path, params = {}) {
+    const res = await fetch(buildUrl(path, params), {
+        headers: {
+            'Content-Type': 'application/json', 'Accept': 'application/json',
+            'FEEDMOB-KEY': API_KEY, 'FEEDMOB-TOKEN': genToken()
+        },
+        signal: AbortSignal.timeout(30000)
+    });
+    if (res.status === 401)
+        throw new Error('Unauthorized: Invalid API Key or Token');
+    if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new Error(err.error || `API error: ${res.status}`);
+    }
+    const r = await res.json();
+    if (r.status === 404)
+        throw new Error(r.error || 'Not found');
+    if (r.status === 400)
+        throw new Error(r.error || 'Bad request');
+    return r.data;
+}
+export async function getAllContacts(month) {
+    return apiGet('/ai/api/client_contacts', month ? { month } : {});
+}
+export async function getContactByClient(name, month) {
+    const p = { client_name: name };
+    if (month)
+        p.month = month;
+    return apiGet('/ai/api/client_contacts', p);
+}
+export async function getClientsByPod(pod, month) {
+    const p = { pod };
+    if (month)
+        p.month = month;
+    return apiGet('/ai/api/client_contacts', p);
+}
+export async function getClientsByRole(role, name, month) {
+    const p = { role, name };
+    if (month)
+        p.month = month;
+    return apiGet('/ai/api/client_contacts', p);
+}
+export async function getClientsByName(name, month) {
+    const p = { name };
+    if (month)
+        p.month = month;
+    return apiGet('/ai/api/client_contacts', p);
+}
+const SLACK_TOKEN = process.env.SLACK_BOT_TOKEN;
+const HUBSPOT_TOKEN = process.env.HUBSPOT_ACCESS_TOKEN;
+async function slackGet(method, params = {}) {
+    if (!SLACK_TOKEN)
+        throw new Error('SLACK_BOT_TOKEN not set');
+    const url = new URL(`https://slack.com/api/${method}`);
+    Object.entries(params).forEach(([k, v]) => url.searchParams.append(k, v));
+    const r = await (await fetch(url.toString(), {
+        headers: { 'Authorization': `Bearer ${SLACK_TOKEN}`, 'Content-Type': 'application/x-www-form-urlencoded' }
+    })).json();
+    if (!r.ok)
+        throw new Error(`Slack error: ${r.error}`);
+    return r;
+}
+export async function findSlackUser(name) {
+    const { members = [] } = await slackGet('users.list');
+    const n = name.toLowerCase();
+    const u = members.find((m) => m.real_name?.toLowerCase().includes(n) || m.name?.toLowerCase().includes(n) || m.profile?.display_name?.toLowerCase().includes(n));
+    return u ? { id: u.id, name: u.name, real_name: u.real_name || u.name, email: u.profile?.email } : null;
+}
+export async function searchSlackMsgs(userName, query, limit = 20) {
+    const user = await findSlackUser(userName);
+    if (!user)
+        throw new Error(`Slack user not found: ${userName}`);
+    const q = query ? `from:${user.name} ${query}` : `from:${user.name}`;
+    const { messages } = await slackGet('search.messages', { query: q, count: String(limit), sort: 'timestamp', sort_dir: 'desc' });
+    return (messages?.matches || []).map((m) => ({
+        ts: m.ts, text: m.text, user: m.username || user.name,
+        channel: m.channel?.name || m.channel?.id || 'unknown', permalink: m.permalink
+    }));
+}
+async function hsPost(endpoint, body) {
+    if (!HUBSPOT_TOKEN)
+        throw new Error('HUBSPOT_ACCESS_TOKEN not set');
+    const res = await fetch(`https://api.hubapi.com${endpoint}`, {
+        method: 'POST',
+        headers: { 'Authorization': `Bearer ${HUBSPOT_TOKEN}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify(body)
+    });
+    if (!res.ok)
+        throw new Error(`HubSpot error: ${res.status} - ${await res.text()}`);
+    return res.json();
+}
+async function hsGet(endpoint) {
+    if (!HUBSPOT_TOKEN)
+        throw new Error('HUBSPOT_ACCESS_TOKEN not set');
+    const res = await fetch(`https://api.hubapi.com${endpoint}`, {
+        headers: { 'Authorization': `Bearer ${HUBSPOT_TOKEN}`, 'Content-Type': 'application/json' }
+    });
+    if (!res.ok)
+        throw new Error(`HubSpot error: ${res.status} - ${await res.text()}`);
+    return res.json();
+}
+function mapTicket(t) {
+    const p = t.properties;
+    return {
+        id: t.id, subject: p.subject || 'No Subject', content: p.content,
+        status: p.hs_pipeline_stage || 'unknown', priority: p.hs_ticket_priority,
+        createdAt: p.createdate, updatedAt: p.hs_lastmodifieddate, owner: p.hubspot_owner_id
+    };
+}
+export async function getTickets(opts = {}) {
+    const filters = [];
+    if (opts.startDate)
+        filters.push({ propertyName: 'createdate', operator: 'GTE', value: new Date(opts.startDate).getTime() });
+    if (opts.endDate)
+        filters.push({ propertyName: 'createdate', operator: 'LTE', value: new Date(opts.endDate).getTime() });
+    if (opts.status)
+        filters.push({ propertyName: 'hs_pipeline_stage', operator: 'EQ', value: opts.status });
+    const body = {
+        properties: ['subject', 'content', 'hs_pipeline_stage', 'hs_ticket_priority', 'createdate', 'hs_lastmodifieddate'],
+        limit: opts.limit || 50, sorts: [{ propertyName: 'createdate', direction: 'DESCENDING' }]
+    };
+    if (filters.length)
+        body.filterGroups = [{ filters }];
+    const { results = [] } = await hsPost('/crm/v3/objects/tickets/search', body);
+    return results.map(mapTicket);
+}
+export async function getTicketById(id) {
+    const props = 'subject,content,hs_pipeline_stage,hs_ticket_priority,createdate,hs_lastmodifieddate';
+    const data = await hsGet(`/crm/v3/objects/tickets/${id}?properties=${props}`);
+    return data ? mapTicket(data) : null;
+}
+export async function getTicketsByUser(opts) {
+    const { results: owners = [] } = await hsGet('/crm/v3/owners');
+    const term = (opts.userName || opts.email || '').toLowerCase();
+    const matched = owners.filter((o) => {
+        const fn = (o.firstName || '').toLowerCase(), ln = (o.lastName || '').toLowerCase();
+        return fn.includes(term) || ln.includes(term) || `${fn} ${ln}`.includes(term) || (o.email || '').toLowerCase().includes(term);
+    });
+    if (!matched.length)
+        return [];
+    const body = {
+        properties: ['subject', 'content', 'hs_pipeline_stage', 'hs_ticket_priority', 'createdate', 'hs_lastmodifieddate', 'hubspot_owner_id'],
+        limit: opts.limit || 50, sorts: [{ propertyName: 'createdate', direction: 'DESCENDING' }],
+        filterGroups: [{ filters: [{ propertyName: 'hubspot_owner_id', operator: 'IN', values: matched.map((o) => o.id) }] }]
+    };
+    const { results = [] } = await hsPost('/crm/v3/objects/tickets/search', body);
+    const ownerMap = new Map(owners.map((o) => [o.id, `${o.firstName || ''} ${o.lastName || ''}`.trim() || o.email]));
+    return results.map((t) => ({ ...mapTicket(t), owner: ownerMap.get(t.properties.hubspot_owner_id) }));
+}

package/dist/index.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import dotenv from 'dotenv';
+import * as api from './api.js';
+dotenv.config();
+const server = new McpServer({ name: 'user-activity-reporting', version: '0.0.3' });
+const errMsg = (e) => e instanceof Error ? e.message : 'Unknown error';
+const errResp = (msg) => ({ content: [{ type: 'text', text: `Error: ${msg}` }], isError: true });
+const textResp = (text) => ({ content: [{ type: 'text', text }] });
+server.tool('get_all_client_contacts', 'Query all client contacts with team members (POD, AA, AM, AE, PM, PA, AO).', {
+    month: z.string().optional().describe('Month in YYYY-MM format'),
+}, async (args) => {
+    try {
+        const d = await api.getAllContacts(args.month);
+        const preview = d.clients.slice(0, 20);
+        const more = d.total > 20 ? `\n... and ${d.total - 20} more` : '';
+        return textResp(`# All Client Contacts\n\nMonth: ${d.month} | Total: ${d.total}\n\n\`\`\`json\n${JSON.stringify(preview, null, 2)}\n\`\`\`${more}`);
+    }
+    catch (e) {
+        return errResp(errMsg(e));
+    }
+});
+server.tool('get_client_team_members', 'Query team members for a client. Returns POD, AA, AM, AE, PM, PA, AO.', {
+    client_name: z.string().describe('Client name (fuzzy match)'),
+    month: z.string().optional().describe('Month in YYYY-MM format'),
+}, async (args) => {
+    try {
+        const d = await api.getContactByClient(args.client_name, args.month);
+        const team = { POD: d.pod || 'N/A', AA: d.aa || 'N/A', AM: d.am || 'N/A', AE: d.ae || 'N/A', PM: d.pm || 'N/A', PA: d.pa || 'N/A', AO: d.ao || 'N/A' };
+        return textResp(`# Team for "${d.client_name}"\n\n\`\`\`json\n${JSON.stringify({ client_id: d.client_id, client_name: d.client_name, month: d.month, team }, null, 2)}\n\`\`\``);
+    }
+    catch (e) {
+        return errResp(errMsg(e));
+    }
+});
+server.tool('get_clients_by_pod', 'Query clients in a POD team.', {
+    pod: z.string().describe('POD name (fuzzy match)'),
+    month: z.string().optional().describe('Month in YYYY-MM format'),
+}, async (args) => {
+    try {
+        const d = await api.getClientsByPod(args.pod, args.month);
+        return textResp(`# Clients in POD: ${d.pod}\n\nMonth: ${d.month} | Count: ${d.count}\n\n${d.client_names.map(c => `- ${c}`).join('\n')}`);
+    }
+    catch (e) {
+        return errResp(errMsg(e));
+    }
+});
+server.tool('get_clients_by_name', 'Query clients managed by a person. Can filter by role.', {
+    name: z.string().describe('Person name'),
+    role: z.enum(['aa', 'am', 'ae', 'pm', 'pa', 'ao']).optional().describe('Role filter'),
+    month: z.string().optional().describe('Month in YYYY-MM format'),
+}, async (args) => {
+    try {
+        if (args.role) {
+            const d = await api.getClientsByRole(args.role, args.name, args.month);
+            return textResp(`# Clients for ${d.role.toUpperCase()}: ${d.name}\n\nMonth: ${d.month} | Count: ${d.count}\n\n${d.client_names.map(c => `- ${c}`).join('\n')}`);
+        }
+        const d = await api.getClientsByName(args.name, args.month);
+        const lines = Object.entries(d.results).map(([r, cs]) => `**${r}:** ${cs.join(', ')}`);
+        return textResp(`# Clients for "${d.name}"\n\nMonth: ${d.month}\n\n${lines.join('\n') || 'No clients found'}`);
+    }
+    catch (e) {
+        return errResp(errMsg(e));
+    }
+});
+server.tool('get_user_slack_history', 'Search Slack messages from a user.', {
+    user_name: z.string().describe('User name'),
+    query: z.string().optional().describe('Keyword filter'),
+    limit: z.number().optional().default(20).describe('Max results'),
+}, async (args) => {
+    try {
+        const msgs = await api.searchSlackMsgs(args.user_name, args.query, args.limit || 20);
+        if (!msgs.length)
+            return textResp(`No Slack messages found for: ${args.user_name}`);
+        const fmt = msgs.map(m => ({ channel: m.channel, text: m.text.slice(0, 200) + (m.text.length > 200 ? '...' : ''), ts: new Date(parseFloat(m.ts) * 1000).toISOString(), link: m.permalink }));
+        return textResp(`# Slack Messages from ${args.user_name}\n\nFound ${msgs.length}\n\n\`\`\`json\n${JSON.stringify(fmt, null, 2)}\n\`\`\``);
+    }
+    catch (e) {
+        return errResp(errMsg(e));
+    }
+});
+server.tool('get_hubspot_tickets', 'Query HubSpot tickets.', {
+    status: z.string().optional().describe('Status filter'),
+    start_date: z.string().optional().describe('Start date YYYY-MM-DD'),
+    end_date: z.string().optional().describe('End date YYYY-MM-DD'),
+    limit: z.number().optional().default(50).describe('Max results'),
+}, async (args) => {
+    try {
+        const tickets = await api.getTickets({ status: args.status, startDate: args.start_date, endDate: args.end_date, limit: args.limit });
+        if (!tickets.length)
+            return textResp('No HubSpot tickets found');
+        const fmt = tickets.map(t => ({ id: t.id, subject: t.subject, status: t.status, priority: t.priority || 'N/A', created: t.createdAt }));
+        return textResp(`# HubSpot Tickets\n\nFound ${tickets.length}\n\n\`\`\`json\n${JSON.stringify(fmt, null, 2)}\n\`\`\``);
+    }
+    catch (e) {
+        return errResp(errMsg(e));
+    }
+});
+server.tool('get_hubspot_ticket_detail', 'Get HubSpot ticket details.', {
+    ticket_id: z.string().describe('Ticket ID'),
+}, async (args) => {
+    try {
+        const t = await api.getTicketById(args.ticket_id);
+        if (!t)
+            return textResp(`Ticket not found: ${args.ticket_id}`);
+        return textResp(`# ${t.subject}\n\n**ID:** ${t.id}\n**Status:** ${t.status}\n**Priority:** ${t.priority || 'N/A'}\n**Created:** ${t.createdAt}\n\n## Description\n\n${t.content || 'No content'}`);
+    }
+    catch (e) {
+        return errResp(errMsg(e));
+    }
+});
+server.tool('get_hubspot_tickets_by_user', 'Query HubSpot tickets by user.', {
+    user_name: z.string().optional().describe('User name'),
+    email: z.string().optional().describe('Email'),
+    limit: z.number().optional().default(50).describe('Max results'),
+}, async (args) => {
+    try {
+        if (!args.user_name && !args.email)
+            return errResp('Provide user_name or email');
+        const tickets = await api.getTicketsByUser({ userName: args.user_name, email: args.email, limit: args.limit });
+        if (!tickets.length)
+            return textResp(`No tickets found for: ${args.user_name || args.email}`);
+        const fmt = tickets.map(t => ({ id: t.id, subject: t.subject, status: t.status, created: t.createdAt }));
+        return textResp(`# Tickets for "${args.user_name || args.email}"\n\nFound ${tickets.length}\n\n\`\`\`json\n${JSON.stringify(fmt, null, 2)}\n\`\`\``);
+    }
+    catch (e) {
+        return errResp(errMsg(e));
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('User Activity Reporting MCP Server running...');
+}
+main();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@feedmob/user-activity-reporting",
+  "version": "0.0.1",
+  "description": "MCP server for querying client contacts, Slack messages, and HubSpot tickets",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "user-activity-reporting": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthropics/fm-mcp-servers.git"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "user-activity",
+    "reporting"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "inspect": "npx fastmcp inspect dist/index.js",
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.24.2",
+    "jsonwebtoken": "^9.0.2",
+    "dotenv": "^16.4.5"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.9",
+    "@types/node": "^22.13.10",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2"
+  }
+}