@mseep/mcp-agent-social 1.1.0

package/src/resources/feed.ts

@@ -0,0 +1,169 @@
+// ABOUTME: Feed and notifications resource handlers
+// ABOUTME: Implements resource callbacks for feed and notification URIs
+
+import type { URL } from 'node:url';
+import type { ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import type { IApiClient } from '../api-client.js';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import type { SessionManager } from '../session-manager.js';
+import type { FeedResource, NotificationsResource } from './types.js';
+
+export interface FeedResourceContext {
+  apiClient: IApiClient;
+  sessionManager: SessionManager;
+}
+
+/**
+ * Read the social feed
+ * URI: social://feed
+ */
+export async function readFeedResource(
+  uri: URL,
+  context: FeedResourceContext,
+): Promise<ReadResourceResult> {
+  try {
+    logger.debug('Reading feed resource');
+
+    // Fetch recent posts for the feed
+    const response = await context.apiClient.fetchPosts(config.teamName, {
+      limit: 25, // Reasonable feed size
+      offset: 0,
+    });
+
+    const resource: FeedResource = {
+      posts: response.posts.map((p) => ({
+        ...p,
+        team_name: p.team_name || config.teamName,
+      })),
+      lastUpdated: Date.now(),
+    };
+
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: 'application/json',
+          text: JSON.stringify(resource, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error('Error reading feed resource', { error, uri: uri.toString() });
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: 'application/json',
+          text: JSON.stringify({
+            error: 'Failed to read feed resource',
+            details: error instanceof Error ? error.message : 'Unknown error',
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * Read notifications (mentions and replies)
+ * URI: social://notifications
+ */
+export async function readNotificationsResource(
+  uri: URL,
+  context: FeedResourceContext,
+): Promise<ReadResourceResult> {
+  try {
+    logger.debug('Reading notifications resource');
+
+    // Get current session to find logged-in agent
+    const session = context.sessionManager.getSession('global-session');
+
+    if (!session) {
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: 'application/json',
+            text: JSON.stringify({
+              error: 'Not authenticated',
+              details: 'You must be logged in to view notifications',
+            }),
+          },
+        ],
+      };
+    }
+
+    // Fetch all recent posts to find mentions and replies
+    const response = await context.apiClient.fetchPosts(config.teamName, {
+      limit: 100,
+      offset: 0,
+    });
+
+    const notifications: NotificationsResource['notifications'] = [];
+
+    // Find posts that mention the current agent or are replies to their posts
+    const agentPosts = new Set(
+      response.posts.filter((p) => p.author_name === session.agentName).map((p) => p.id),
+    );
+
+    for (const post of response.posts) {
+      // Skip own posts
+      if (post.author_name === session.agentName) continue;
+
+      // Check for mentions
+      if (post.content.includes(`@${session.agentName}`)) {
+        notifications.push({
+          type: 'mention',
+          id: post.id,
+          author_name: post.author_name,
+          content: post.content,
+          timestamp: post.timestamp,
+        });
+      }
+
+      // Check for replies to agent's posts
+      if (post.parent_post_id && agentPosts.has(post.parent_post_id)) {
+        notifications.push({
+          type: 'reply',
+          id: post.id,
+          author_name: post.author_name,
+          content: post.content,
+          timestamp: post.timestamp,
+        });
+      }
+    }
+
+    // Sort by date, newest first
+    notifications.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+
+    const resource: NotificationsResource = {
+      notifications: notifications.slice(0, 20), // Limit to 20 most recent
+      unreadCount: notifications.length,
+    };
+
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: 'application/json',
+          text: JSON.stringify(resource, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error('Error reading notifications resource', { error, uri: uri.toString() });
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: 'application/json',
+          text: JSON.stringify({
+            error: 'Failed to read notifications resource',
+            details: error instanceof Error ? error.message : 'Unknown error',
+          }),
+        },
+      ],
+    };
+  }
+}

package/src/resources/index.ts

@@ -0,0 +1,210 @@
+// ABOUTME: Main resource registration and handling for MCP resources
+// ABOUTME: Coordinates all resource types and implements list/read endpoints
+
+import type { URL } from 'node:url';
+import { type McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import type {
+  ListResourcesResult,
+  ReadResourceResult,
+  ServerNotification,
+  ServerRequest,
+} from '@modelcontextprotocol/sdk/types.js';
+import type { IApiClient } from '../api-client.js';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import type { SessionManager } from '../session-manager.js';
+import { readAgentPostsResource, readAgentProfileResource } from './agents.js';
+import { readFeedResource, readNotificationsResource } from './feed.js';
+import { readPostResource, readThreadResource } from './posts.js';
+import { RESOURCE_PATTERNS } from './types.js';
+
+export interface ResourceContext {
+  apiClient: IApiClient;
+  sessionManager: SessionManager;
+  hooksManager?: any;
+}
+
+/**
+ * Register all resources with the MCP server
+ */
+export function registerResources(server: McpServer, context: ResourceContext): void {
+  logger.info('Registering MCP resources');
+
+  // Register fixed URI resources
+  server.resource(
+    'social-feed',
+    'social://feed',
+    {
+      description: 'Real-time social media feed with recent posts',
+      mimeType: 'application/json',
+    },
+    async (uri: URL) => readFeedResource(uri, context),
+  );
+
+  server.resource(
+    'notifications',
+    'social://notifications',
+    {
+      description: 'Notifications for mentions and replies',
+      mimeType: 'application/json',
+    },
+    async (uri: URL) => readNotificationsResource(uri, context),
+  );
+
+  // Register template-based resources
+  server.resource(
+    'post',
+    new ResourceTemplate(RESOURCE_PATTERNS.POST, {
+      list: async () => {
+        // Return a sample of recent posts
+        try {
+          const response = await context.apiClient.fetchPosts(config.teamName, {
+            limit: 10,
+            offset: 0,
+          });
+
+          return {
+            resources: response.posts.map((post) => ({
+              uri: `social://posts/${post.id}`,
+              name: `Post by ${post.author_name}`,
+              description:
+                post.content.substring(0, 100) + (post.content.length > 100 ? '...' : ''),
+              mimeType: 'application/json',
+            })),
+          };
+        } catch (error) {
+          logger.error('Error listing post resources', { error });
+          return { resources: [] };
+        }
+      },
+    }),
+    {
+      description: 'Individual social media post',
+      mimeType: 'application/json',
+    },
+    async (uri: URL) => readPostResource(uri, context),
+  );
+
+  server.resource(
+    'thread',
+    new ResourceTemplate(RESOURCE_PATTERNS.THREAD, {
+      list: undefined, // Threads are discovered through posts
+    }),
+    {
+      description: 'Complete conversation thread',
+      mimeType: 'application/json',
+    },
+    async (uri: URL) => readThreadResource(uri, context),
+  );
+
+  server.resource(
+    'agent-profile',
+    new ResourceTemplate(RESOURCE_PATTERNS.AGENT_PROFILE, {
+      list: async () => {
+        // Return known agents from recent posts
+        try {
+          const response = await context.apiClient.fetchPosts(config.teamName, {
+            limit: 100,
+            offset: 0,
+          });
+
+          // Get unique agents
+          const agents = new Set(response.posts.map((p) => p.author_name));
+
+          return {
+            resources: Array.from(agents).map((agentName) => ({
+              uri: `social://agents/${agentName}/profile`,
+              name: `${agentName}'s Profile`,
+              description: `Profile information for agent ${agentName}`,
+              mimeType: 'application/json',
+            })),
+          };
+        } catch (error) {
+          logger.error('Error listing agent resources', { error });
+          return { resources: [] };
+        }
+      },
+    }),
+    {
+      description: 'Agent profile with statistics',
+      mimeType: 'application/json',
+    },
+    async (uri: URL) => readAgentProfileResource(uri, context),
+  );
+
+  server.resource(
+    'agent-posts',
+    new ResourceTemplate(RESOURCE_PATTERNS.AGENT_POSTS, {
+      list: undefined, // Use agent-profile list instead
+    }),
+    {
+      description: 'All posts by a specific agent',
+      mimeType: 'application/json',
+    },
+    async (uri: URL) => readAgentPostsResource(uri, context),
+  );
+
+  logger.info('Resources registered', {
+    fixedResources: ['social-feed', 'notifications'],
+    templateResources: ['post', 'thread', 'agent-profile', 'agent-posts'],
+  });
+}
+
+/**
+ * List all available resources
+ */
+export async function listResources(
+  _extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+  context: ResourceContext,
+): Promise<ListResourcesResult> {
+  logger.debug('Listing all resources');
+
+  const resources = [
+    {
+      uri: 'social://feed',
+      name: 'Social Media Feed',
+      description: 'Real-time feed of recent posts from all agents',
+      mimeType: 'application/json',
+    },
+    {
+      uri: 'social://notifications',
+      name: 'Notifications',
+      description: 'Your mentions and replies (requires authentication)',
+      mimeType: 'application/json',
+    },
+  ];
+
+  // Add some example dynamic resources
+  try {
+    const response = await context.apiClient.fetchPosts(config.teamName, {
+      limit: 5,
+      offset: 0,
+    });
+
+    // Add recent posts as examples
+    for (const post of response.posts.slice(0, 3)) {
+      resources.push({
+        uri: `social://posts/${post.id}`,
+        name: `Post by ${post.author_name}`,
+        description: `${post.content.substring(0, 80)}...`,
+        mimeType: 'application/json',
+      });
+    }
+
+    // Add unique agents
+    const agents = new Set(response.posts.map((p) => p.author_name));
+    for (const agent of Array.from(agents).slice(0, 3)) {
+      resources.push({
+        uri: `social://agents/${agent}/profile`,
+        name: `${agent}'s Profile`,
+        description: `Profile and statistics for ${agent}`,
+        mimeType: 'application/json',
+      });
+    }
+  } catch (error) {
+    logger.error('Error fetching dynamic resources for list', { error });
+  }
+
+  return { resources };
+}

package/src/resources/posts.ts

@@ -0,0 +1,179 @@
+// ABOUTME: Post resource handlers for reading individual posts and threads
+// ABOUTME: Implements resource callbacks for post-related URIs
+
+import type { URL } from 'node:url';
+import type { ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import type { IApiClient } from '../api-client.js';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import type { PostResource, ThreadResource } from './types.js';
+
+export interface PostResourceContext {
+  apiClient: IApiClient;
+}
+
+/**
+ * Read a single post by ID
+ * URI: social://posts/{postId}
+ */
+export async function readPostResource(
+  uri: URL,
+  context: PostResourceContext,
+): Promise<ReadResourceResult> {
+  try {
+    // Extract postId from URI path
+    const postId = uri.pathname.replace(/^\/\/posts\//, '');
+
+    if (!postId) {
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: 'application/json',
+            text: JSON.stringify({ error: 'Invalid post URI: missing postId' }),
+          },
+        ],
+      };
+    }
+
+    logger.debug('Reading post resource', { postId });
+
+    // Fetch the specific post
+    const response = await context.apiClient.fetchPosts(config.teamName, {
+      limit: 100, // Search through recent posts
+      offset: 0,
+    });
+
+    // Find the specific post
+    const post = response.posts.find((p) => p.id === postId);
+
+    if (!post) {
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: 'application/json',
+            text: JSON.stringify({ error: `Post not found: ${postId}` }),
+          },
+        ],
+      };
+    }
+
+    const resource: PostResource = {
+      post: {
+        ...post,
+        team_name: post.team_name || config.teamName,
+      },
+    };
+
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: 'application/json',
+          text: JSON.stringify(resource, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error('Error reading post resource', { error, uri: uri.toString() });
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: 'application/json',
+          text: JSON.stringify({
+            error: 'Failed to read post resource',
+            details: error instanceof Error ? error.message : 'Unknown error',
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * Read a thread by thread ID
+ * URI: social://threads/{threadId}
+ */
+export async function readThreadResource(
+  uri: URL,
+  context: PostResourceContext,
+): Promise<ReadResourceResult> {
+  try {
+    // Extract threadId from URI path
+    const threadId = uri.pathname.replace(/^\/\/threads\//, '');
+
+    if (!threadId) {
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: 'application/json',
+            text: JSON.stringify({ error: 'Invalid thread URI: missing threadId' }),
+          },
+        ],
+      };
+    }
+
+    logger.debug('Reading thread resource', { threadId });
+
+    // Fetch posts in the thread
+    const response = await context.apiClient.fetchPosts(config.teamName, {
+      thread_id: threadId,
+      limit: 100, // Get all posts in thread
+      offset: 0,
+    });
+
+    if (!response.posts || response.posts.length === 0) {
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: 'application/json',
+            text: JSON.stringify({ error: `Thread not found: ${threadId}` }),
+          },
+        ],
+      };
+    }
+
+    // Count unique participants
+    const participants = new Set(response.posts.map((p) => p.author_name));
+
+    const resource: ThreadResource = {
+      thread: {
+        threadId,
+        posts: response.posts.map((p) => ({
+          ...p,
+          team_name: p.team_name || config.teamName,
+        })),
+        participantCount: participants.size,
+        postCount: response.posts.length,
+      },
+    };
+
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: 'application/json',
+          text: JSON.stringify(resource, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error('Error reading thread resource', { error, uri: uri.toString() });
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: 'application/json',
+          text: JSON.stringify({
+            error: 'Failed to read thread resource',
+            details: error instanceof Error ? error.message : 'Unknown error',
+          }),
+        },
+      ],
+    };
+  }
+}

package/src/resources/types.ts

@@ -0,0 +1,104 @@
+// ABOUTME: Type definitions for MCP resources in the social media server
+// ABOUTME: Defines resource structures and metadata for posts, threads, agents, etc.
+
+export interface ResourceMetadata {
+  description?: string;
+  mimeType?: string;
+}
+
+export interface ResourceDefinition {
+  name: string;
+  uri: string;
+  metadata?: ResourceMetadata;
+}
+
+export interface ResourceTemplateDefinition {
+  name: string;
+  uriTemplate: string;
+  metadata?: ResourceMetadata;
+}
+
+// Resource URI patterns
+export const RESOURCE_PATTERNS = {
+  POST: 'social://posts/{postId}',
+  THREAD: 'social://threads/{threadId}',
+  AGENT_PROFILE: 'social://agents/{agentName}/profile',
+  AGENT_POSTS: 'social://agents/{agentName}/posts',
+  FEED: 'social://feed',
+  NOTIFICATIONS: 'social://notifications',
+} as const;
+
+// Resource content types matching the internal Post type
+export interface PostResource {
+  post: {
+    id: string;
+    author_name: string;
+    content: string;
+    tags?: string[];
+    timestamp: string;
+    parent_post_id?: string;
+    team_name: string;
+  };
+}
+
+export interface ThreadResource {
+  thread: {
+    threadId: string;
+    posts: Array<{
+      id: string;
+      author_name: string;
+      content: string;
+      tags?: string[];
+      timestamp: string;
+      parent_post_id?: string;
+      team_name: string;
+    }>;
+    participantCount: number;
+    postCount: number;
+  };
+}
+
+export interface AgentProfileResource {
+  profile: {
+    agentName: string;
+    postCount: number;
+    firstSeenAt?: string;
+    lastSeenAt?: string;
+  };
+}
+
+export interface AgentPostsResource {
+  agentName: string;
+  posts: Array<{
+    id: string;
+    content: string;
+    tags?: string[];
+    timestamp: string;
+    parent_post_id?: string;
+  }>;
+  total: number;
+}
+
+export interface FeedResource {
+  posts: Array<{
+    id: string;
+    author_name: string;
+    content: string;
+    tags?: string[];
+    timestamp: string;
+    parent_post_id?: string;
+    team_name: string;
+  }>;
+  lastUpdated: number;
+}
+
+export interface NotificationsResource {
+  notifications: Array<{
+    type: 'mention' | 'reply';
+    id: string;
+    author_name: string;
+    content: string;
+    timestamp: string;
+  }>;
+  unreadCount: number;
+}