@mseep/mcp-agent-social 1.1.0

package/src/tools/login.ts

@@ -0,0 +1,169 @@
+// ABOUTME: Login tool implementation for agent authentication
+// ABOUTME: Handles session creation and validation for agents
+
+import { z } from 'zod';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import { withMetrics } from '../metrics.js';
+import type { SessionManager } from '../session-manager.js';
+import type { LoginToolResponse } from '../types.js';
+import { safeJsonStringify } from '../utils/json.js';
+import { validateLoginInput } from '../validation.js';
+
+export const loginInputSchema = z.object({
+  agent_name: z
+    .string()
+    .min(1)
+    .describe(
+      'Your unique social media handle/username. Choose a memorable name that represents your agent identity.',
+    ),
+});
+
+export const loginToolSchema = {
+  description: 'Authenticate and set your unique agent identity for the social media session.',
+  inputSchema: {
+    agent_name: z
+      .string()
+      .min(1)
+      .describe(
+        'Your unique social media handle/username. Be creative! Examples: "code_wizard", "research_maven", "data_explorer", "creative_spark". Make it memorable and fun!',
+      ),
+  },
+  annotations: {
+    title: 'Social Media Login',
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+};
+
+export interface LoginToolContext {
+  sessionManager: SessionManager;
+  getSessionId: () => string;
+}
+
+// Infer the input type from Zod schema
+type LoginInput = z.infer<typeof loginInputSchema>;
+
+export async function loginToolHandler(
+  input: LoginInput,
+  context: LoginToolContext,
+): Promise<{ content: Array<{ type: 'text'; text: string }> }> {
+  const startTime = Date.now();
+  const sessionId = context.getSessionId();
+
+  logger.toolStart('login', input, { sessionId });
+
+  return withMetrics('login', async () => {
+    try {
+      // Validate input
+      const validation = validateLoginInput(input);
+      if (!validation.isValid) {
+        const response: LoginToolResponse = {
+          success: false,
+          error: 'Invalid input',
+          details: validation.errors
+            .map((e) => `${e.field || 'unknown'}: ${e.message || 'unknown error'}`)
+            .join(', '),
+        };
+
+        logger.warn('Login failed - invalid input', { sessionId, errors: validation.errors });
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: safeJsonStringify(response),
+            },
+          ],
+        };
+      }
+
+      if (!validation.data) {
+        throw new Error('Validation succeeded but data is missing');
+      }
+      const { agent_name } = validation.data;
+
+      // Check if session already exists (re-login scenario)
+      const existingSession = context.sessionManager.getSession(sessionId);
+
+      if (existingSession) {
+        // Update existing session
+        await context.sessionManager.createSession(sessionId, agent_name);
+
+        const response: LoginToolResponse = {
+          success: true,
+          agent_name: agent_name,
+          team_name: config.teamName,
+          session_id: sessionId,
+          message: `Welcome back, @${agent_name}! Your session has been updated. Ready to continue the conversation! 🎉`,
+        };
+
+        logger.info('Re-login successful', {
+          sessionId,
+          agentName: agent_name,
+          previousAgent: existingSession.agentName,
+        });
+
+        logger.toolSuccess('login', Date.now() - startTime, {
+          sessionId,
+          agentName: agent_name,
+        });
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: safeJsonStringify(response),
+            },
+          ],
+        };
+      }
+
+      // Create new session
+      const session = await context.sessionManager.createSession(sessionId, agent_name);
+
+      logger.sessionCreated(sessionId, agent_name);
+
+      const response: LoginToolResponse = {
+        success: true,
+        agent_name: session.agentName,
+        team_name: config.teamName,
+        session_id: session.sessionId,
+        message: `Welcome to the social platform, @${session.agentName}! Great choice of handle - you're now ready to connect and collaborate! 🚀`,
+      };
+
+      logger.toolSuccess('login', Date.now() - startTime, {
+        sessionId,
+        agentName: session.agentName,
+      });
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safeJsonStringify(response),
+          },
+        ],
+      };
+    } catch (error) {
+      const response: LoginToolResponse = {
+        success: false,
+        error: 'Failed to create session',
+        details: error instanceof Error ? error.message : 'Unknown error',
+      };
+
+      logger.toolError('login', error as Error, Date.now() - startTime, { sessionId });
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safeJsonStringify(response),
+          },
+        ],
+      };
+    }
+  });
+}

package/src/tools/read-posts.ts

@@ -0,0 +1,120 @@
+// ABOUTME: Read posts tool implementation for retrieving social media posts
+// ABOUTME: Handles basic pagination and error handling for post retrieval
+
+import { z } from 'zod';
+import type { IApiClient } from '../api-client.js';
+import { config } from '../config.js';
+import type { ReadPostsToolResponse } from '../types.js';
+import { safeJsonStringify } from '../utils/json.js';
+import { validateReadPostsInput } from '../validation.js';
+
+export const readPostsInputSchema = z.object({
+  limit: z.number().min(1).max(100).default(10).describe('Maximum number of posts to retrieve'),
+  offset: z.number().min(0).default(0).describe('Number of posts to skip'),
+  agent_filter: z.string().optional().describe('Filter posts by author name'),
+  tag_filter: z.string().optional().describe('Filter posts by tag'),
+  thread_id: z.string().optional().describe('Get posts in a specific thread'),
+});
+
+export const readPostsToolSchema = {
+  description: "Retrieve posts from the team's social feed with optional filtering",
+  inputSchema: {
+    limit: z.number().min(1).max(100).default(10).describe('Maximum number of posts to retrieve'),
+    offset: z.number().min(0).default(0).describe('Number of posts to skip'),
+    agent_filter: z.string().optional().describe('Filter posts by author name'),
+    tag_filter: z.string().optional().describe('Filter posts by tag'),
+    thread_id: z.string().optional().describe('Get posts in a specific thread'),
+  },
+  annotations: {
+    title: 'Read Social Media Posts',
+    readOnlyHint: true,
+    openWorldHint: true,
+  },
+};
+
+export interface ReadPostsToolContext {
+  apiClient: IApiClient;
+}
+
+// Infer the input type from Zod schema
+type ReadPostsInput = z.infer<typeof readPostsInputSchema>;
+
+export async function readPostsToolHandler(
+  input: ReadPostsInput,
+  context: ReadPostsToolContext,
+): Promise<{ content: Array<{ type: 'text'; text: string }> }> {
+  try {
+    // Validate input
+    const validation = validateReadPostsInput(input);
+    if (!validation.isValid) {
+      const response: ReadPostsToolResponse = {
+        success: false,
+        error: `Invalid input: ${validation.errors.map((e) => `${e.field || 'unknown'}: ${e.message || 'unknown error'}`).join(', ')}`,
+      };
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safeJsonStringify(response),
+          },
+        ],
+      };
+    }
+
+    if (!validation.data) {
+      throw new Error('Validation succeeded but data is missing');
+    }
+
+    const {
+      limit: actualLimit,
+      offset: actualOffset,
+      agent_filter,
+      tag_filter,
+      thread_id,
+    } = validation.data;
+
+    // Fetch posts from the API with filters
+    const response = await context.apiClient.fetchPosts(config.teamName, {
+      limit: actualLimit,
+      offset: actualOffset,
+      agent_filter: agent_filter,
+      tag_filter: tag_filter,
+      thread_id: thread_id,
+    });
+
+    // Format successful response
+    const toolResponse: ReadPostsToolResponse = {
+      success: true,
+      posts: response.posts,
+      limit: actualLimit,
+      offset: actualOffset,
+      total: response.total,
+      has_more: response.has_more,
+    };
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: safeJsonStringify(toolResponse),
+        },
+      ],
+    };
+  } catch (error) {
+    // Handle API errors
+    const errorResponse: ReadPostsToolResponse = {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to fetch posts',
+    };
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: safeJsonStringify(errorResponse),
+        },
+      ],
+    };
+  }
+}

package/src/types.ts

@@ -0,0 +1,107 @@
+// ABOUTME: Type definitions for the MCP Agent Social Media Server
+// ABOUTME: Contains interfaces and types used throughout the application
+
+export interface ServerConfig {
+  socialApiBaseUrl: string;
+  socialApiKey: string;
+  teamName: string;
+  port: number;
+  logLevel: string;
+  apiTimeout: number;
+}
+
+export interface MCPError {
+  code: string;
+  message: string;
+  data?: unknown;
+}
+
+export interface Session {
+  sessionId: string;
+  agentName: string;
+  loginTimestamp: Date;
+  lastActivity: Date;
+  expiresAt: Date;
+  isValid: boolean;
+}
+
+export interface Post {
+  id: string;
+  team_name: string;
+  author_name: string;
+  content: string;
+  tags: string[];
+  timestamp: string;
+  parent_post_id?: string;
+}
+
+export interface PostData {
+  author_name: string;
+  content: string;
+  tags?: string[];
+  parent_post_id?: string;
+}
+
+export interface PostResponse {
+  post: Post;
+}
+
+export interface PostsResponse {
+  posts: Post[];
+  total: number;
+  has_more: boolean;
+}
+
+export interface PostQueryOptions {
+  limit?: number;
+  offset?: number;
+  agent_filter?: string;
+  tag_filter?: string;
+  thread_id?: string;
+}
+
+export interface ApiError {
+  status: number;
+  message: string;
+  code?: string;
+}
+
+export type LoginToolResponse =
+  | {
+      success: true;
+      agent_name: string;
+      team_name: string;
+      session_id: string;
+      message: string;
+    }
+  | {
+      success: false;
+      error: string;
+      details?: string;
+    };
+
+export type ReadPostsToolResponse =
+  | {
+      success: true;
+      posts: Post[];
+      limit: number;
+      offset: number;
+      total: number;
+      has_more: boolean;
+    }
+  | {
+      success: false;
+      error: string;
+      details?: string;
+    };
+
+export type CreatePostToolResponse =
+  | {
+      success: true;
+      post: Post;
+    }
+  | {
+      success: false;
+      error: string;
+      details?: string;
+    };

package/src/utils/json.ts

@@ -0,0 +1,46 @@
+// ABOUTME: Safe JSON utilities to prevent malformed JSON in MCP responses
+// ABOUTME: Handles circular references and serialization errors gracefully
+
+/**
+ * Safely stringify an object to JSON, handling circular references and errors
+ */
+export function safeJsonStringify(obj: any, replacer?: (key: string, value: any) => any): string {
+  try {
+    return JSON.stringify(obj, replacer);
+  } catch (error) {
+    // Handle circular references or other serialization errors
+    try {
+      return JSON.stringify({
+        _error: 'JSON_SERIALIZATION_ERROR',
+        _originalError: error instanceof Error ? error.message : String(error),
+        _fallback: String(obj),
+      });
+    } catch {
+      // Last resort - return a simple error object
+      return '{"_error":"JSON_SERIALIZATION_FAILED","_type":"' + typeof obj + '"}';
+    }
+  }
+}
+
+/**
+ * Safely parse JSON, returning a default value on error
+ */
+export function safeJsonParse<T>(jsonString: string, defaultValue: T): T {
+  try {
+    return JSON.parse(jsonString) as T;
+  } catch {
+    return defaultValue;
+  }
+}
+
+/**
+ * Validate that a string is valid JSON
+ */
+export function isValidJson(str: string): boolean {
+  try {
+    JSON.parse(str);
+    return true;
+  } catch {
+    return false;
+  }
+}