mcpeasy 0.1.0

data/lib/utilities/gmeet/mcp.rb

@@ -0,0 +1,438 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "json"
+require_relative "gmeet_tool"
+
+class MCPServer
+  def initialize
+    # Defer GmeetTool initialization until actually needed
+    @gmeet_tool = nil
+    @tools = {
+      "test_connection" => {
+        name: "test_connection",
+        description: "Test the Google Calendar API connection",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      "list_meetings" => {
+        name: "list_meetings",
+        description: "List Google Meet meetings with optional date filtering",
+        inputSchema: {
+          type: "object",
+          properties: {
+            start_date: {
+              type: "string",
+              description: "Start date in YYYY-MM-DD format (default: today)"
+            },
+            end_date: {
+              type: "string",
+              description: "End date in YYYY-MM-DD format (default: 7 days from start)"
+            },
+            max_results: {
+              type: "number",
+              description: "Maximum number of meetings to return (default: 20)"
+            },
+            calendar_id: {
+              type: "string",
+              description: "Calendar ID to list meetings from (default: primary calendar)"
+            }
+          },
+          required: []
+        }
+      },
+      "upcoming_meetings" => {
+        name: "upcoming_meetings",
+        description: "List upcoming Google Meet meetings in the next 24 hours",
+        inputSchema: {
+          type: "object",
+          properties: {
+            max_results: {
+              type: "number",
+              description: "Maximum number of meetings to return (default: 10)"
+            },
+            calendar_id: {
+              type: "string",
+              description: "Calendar ID to list meetings from (default: primary calendar)"
+            }
+          },
+          required: []
+        }
+      },
+      "search_meetings" => {
+        name: "search_meetings",
+        description: "Search for Google Meet meetings by text content",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query to find meetings"
+            },
+            start_date: {
+              type: "string",
+              description: "Start date in YYYY-MM-DD format (default: today)"
+            },
+            end_date: {
+              type: "string",
+              description: "End date in YYYY-MM-DD format (default: 30 days from start)"
+            },
+            max_results: {
+              type: "number",
+              description: "Maximum number of meetings to return (default: 10)"
+            }
+          },
+          required: ["query"]
+        }
+      },
+      "get_meeting_url" => {
+        name: "get_meeting_url",
+        description: "Get the Google Meet URL for a specific event",
+        inputSchema: {
+          type: "object",
+          properties: {
+            event_id: {
+              type: "string",
+              description: "Calendar event ID"
+            },
+            calendar_id: {
+              type: "string",
+              description: "Calendar ID (default: primary calendar)"
+            }
+          },
+          required: ["event_id"]
+        }
+      }
+    }
+  end
+
+  def run
+    # Disable stdout buffering for immediate response
+    $stdout.sync = true
+
+    # Log startup to file instead of stdout to avoid protocol interference
+    Mcpeasy::Config.ensure_config_dirs
+    File.write(Mcpeasy::Config.log_file_path("gmeet", "startup"), "#{Time.now}: Google Meet MCP Server starting on stdio\n", mode: "a")
+    while (line = $stdin.gets)
+      handle_request(line.strip)
+    end
+  rescue Interrupt
+    # Silent shutdown
+  rescue => e
+    # Log to a file instead of stderr to avoid protocol interference
+    File.write(Mcpeasy::Config.log_file_path("gmeet", "error"), "#{Time.now}: #{e.message}\n#{e.backtrace.join("\n")}\n", mode: "a")
+  end
+
+  private
+
+  def handle_request(line)
+    return if line.empty?
+
+    begin
+      request = JSON.parse(line)
+      response = process_request(request)
+      if response
+        puts JSON.generate(response)
+        $stdout.flush
+      end
+    rescue JSON::ParserError => e
+      error_response = {
+        jsonrpc: "2.0",
+        id: nil,
+        error: {
+          code: -32700,
+          message: "Parse error",
+          data: e.message
+        }
+      }
+      puts JSON.generate(error_response)
+      $stdout.flush
+    rescue => e
+      File.write(Mcpeasy::Config.log_file_path("gmeet", "error"), "#{Time.now}: Error handling request: #{e.message}\n#{e.backtrace.join("\n")}\n", mode: "a")
+      error_response = {
+        jsonrpc: "2.0",
+        id: request&.dig("id"),
+        error: {
+          code: -32603,
+          message: "Internal error",
+          data: e.message
+        }
+      }
+      puts JSON.generate(error_response)
+      $stdout.flush
+    end
+  end
+
+  def process_request(request)
+    id = request["id"]
+    method = request["method"]
+    params = request["params"] || {}
+
+    case method
+    when "notifications/initialized"
+      # Client acknowledgment - no response needed
+      nil
+    when "initialize"
+      initialize_response(id, params)
+    when "tools/list"
+      tools_list_response(id, params)
+    when "tools/call"
+      tools_call_response(id, params)
+    else
+      {
+        jsonrpc: "2.0",
+        id: id,
+        error: {
+          code: -32601,
+          message: "Method not found",
+          data: "Unknown method: #{method}"
+        }
+      }
+    end
+  end
+
+  def initialize_response(id, params)
+    {
+      jsonrpc: "2.0",
+      id: id,
+      result: {
+        protocolVersion: "2024-11-05",
+        capabilities: {
+          tools: {}
+        },
+        serverInfo: {
+          name: "gmeet-mcp-server",
+          version: "1.0.0"
+        }
+      }
+    }
+  end
+
+  def tools_list_response(id, params)
+    {
+      jsonrpc: "2.0",
+      id: id,
+      result: {
+        tools: @tools.values
+      }
+    }
+  end
+
+  def tools_call_response(id, params)
+    tool_name = params["name"]
+    arguments = params["arguments"] || {}
+
+    unless @tools.key?(tool_name)
+      return {
+        jsonrpc: "2.0",
+        id: id,
+        error: {
+          code: -32602,
+          message: "Unknown tool",
+          data: "Tool '#{tool_name}' not found"
+        }
+      }
+    end
+
+    begin
+      result = call_tool(tool_name, arguments)
+      {
+        jsonrpc: "2.0",
+        id: id,
+        result: {
+          content: [
+            {
+              type: "text",
+              text: result
+            }
+          ],
+          isError: false
+        }
+      }
+    rescue => e
+      File.write(Mcpeasy::Config.log_file_path("gmeet", "error"), "#{Time.now}: Tool error: #{e.message}\n#{e.backtrace.join("\n")}\n", mode: "a")
+      {
+        jsonrpc: "2.0",
+        id: id,
+        result: {
+          content: [
+            {
+              type: "text",
+              text: "❌ Error: #{e.message}"
+            }
+          ],
+          isError: true
+        }
+      }
+    end
+  end
+
+  def call_tool(tool_name, arguments)
+    # Initialize GmeetTool only when needed
+    @gmeet_tool ||= GmeetTool.new
+
+    case tool_name
+    when "test_connection"
+      test_connection
+    when "list_meetings"
+      list_meetings(arguments)
+    when "upcoming_meetings"
+      upcoming_meetings(arguments)
+    when "search_meetings"
+      search_meetings(arguments)
+    when "get_meeting_url"
+      get_meeting_url(arguments)
+    else
+      raise "Unknown tool: #{tool_name}"
+    end
+  end
+
+  def test_connection
+    response = @gmeet_tool.test_connection
+    if response[:ok]
+      "✅ Successfully connected to Google Calendar.\n" \
+      "   User: #{response[:user]} (#{response[:email]})"
+    else
+      raise "Connection test failed"
+    end
+  end
+
+  def list_meetings(arguments)
+    start_date = arguments["start_date"]
+    end_date = arguments["end_date"]
+    max_results = arguments["max_results"]&.to_i || 20
+    calendar_id = arguments["calendar_id"] || "primary"
+
+    result = @gmeet_tool.list_meetings(
+      start_date: start_date,
+      end_date: end_date,
+      max_results: max_results,
+      calendar_id: calendar_id
+    )
+    meetings = result[:meetings]
+
+    if meetings.empty?
+      "🎥 No Google Meet meetings found for the specified date range"
+    else
+      output = "🎥 Found #{result[:count]} Google Meet meeting(s):\n\n"
+      meetings.each_with_index do |meeting, index|
+        output << "#{index + 1}. **#{meeting[:summary] || "No title"}**\n"
+        output << "   - Start: #{format_datetime(meeting[:start])}\n"
+        output << "   - End: #{format_datetime(meeting[:end])}\n"
+        output << "   - Description: #{meeting[:description] || "No description"}\n" if meeting[:description]
+        output << "   - Location: #{meeting[:location]}\n" if meeting[:location]
+        output << "   - Attendees: #{meeting[:attendees].join(", ")}\n" if meeting[:attendees]&.any?
+        output << "   - **Meet Link: #{meeting[:meet_link]}**\n"
+        output << "   - Calendar Link: #{meeting[:html_link]}\n\n"
+      end
+      output
+    end
+  end
+
+  def upcoming_meetings(arguments)
+    max_results = arguments["max_results"]&.to_i || 10
+    calendar_id = arguments["calendar_id"] || "primary"
+
+    result = @gmeet_tool.upcoming_meetings(
+      max_results: max_results,
+      calendar_id: calendar_id
+    )
+    meetings = result[:meetings]
+
+    if meetings.empty?
+      "🎥 No upcoming Google Meet meetings found in the next 24 hours"
+    else
+      output = "🎥 Found #{result[:count]} upcoming Google Meet meeting(s):\n\n"
+      meetings.each_with_index do |meeting, index|
+        output << "#{index + 1}. **#{meeting[:summary] || "No title"}**\n"
+        output << "   - Start: #{format_datetime(meeting[:start])} (#{meeting[:time_until_start]})\n"
+        output << "   - End: #{format_datetime(meeting[:end])}\n"
+        output << "   - Description: #{meeting[:description] || "No description"}\n" if meeting[:description]
+        output << "   - Location: #{meeting[:location]}\n" if meeting[:location]
+        output << "   - Attendees: #{meeting[:attendees].join(", ")}\n" if meeting[:attendees]&.any?
+        output << "   - **Meet Link: #{meeting[:meet_link]}**\n"
+        output << "   - Calendar Link: #{meeting[:html_link]}\n\n"
+      end
+      output
+    end
+  end
+
+  def search_meetings(arguments)
+    unless arguments["query"]
+      raise "Missing required argument: query"
+    end
+
+    query = arguments["query"].to_s
+    start_date = arguments["start_date"]
+    end_date = arguments["end_date"]
+    max_results = arguments["max_results"]&.to_i || 10
+
+    result = @gmeet_tool.search_meetings(
+      query,
+      start_date: start_date,
+      end_date: end_date,
+      max_results: max_results
+    )
+    meetings = result[:meetings]
+
+    if meetings.empty?
+      "🔍 No Google Meet meetings found matching '#{query}'"
+    else
+      output = "🔍 Found #{result[:count]} Google Meet meeting(s) matching '#{query}':\n\n"
+      meetings.each_with_index do |meeting, index|
+        output << "#{index + 1}. **#{meeting[:summary] || "No title"}**\n"
+        output << "   - Start: #{format_datetime(meeting[:start])}\n"
+        output << "   - End: #{format_datetime(meeting[:end])}\n"
+        output << "   - Description: #{meeting[:description] || "No description"}\n" if meeting[:description]
+        output << "   - Location: #{meeting[:location]}\n" if meeting[:location]
+        output << "   - **Meet Link: #{meeting[:meet_link]}**\n"
+        output << "   - Calendar Link: #{meeting[:html_link]}\n\n"
+      end
+      output
+    end
+  end
+
+  def get_meeting_url(arguments)
+    unless arguments["event_id"]
+      raise "Missing required argument: event_id"
+    end
+
+    event_id = arguments["event_id"].to_s
+    calendar_id = arguments["calendar_id"] || "primary"
+
+    result = @gmeet_tool.get_meeting_url(event_id, calendar_id: calendar_id)
+
+    output = "🎥 **#{result[:summary] || "Meeting"}**\n"
+    output << "   - Start: #{format_datetime(result[:start])}\n"
+    output << "   - End: #{format_datetime(result[:end])}\n"
+    output << "   - **Meet Link: #{result[:meet_link]}**\n"
+    output << "   - Event ID: #{result[:event_id]}\n"
+
+    output
+  end
+
+  private
+
+  def format_datetime(datetime_info)
+    return "Unknown" unless datetime_info
+
+    if datetime_info[:date]
+      # All-day event
+      datetime_info[:date]
+    elsif datetime_info[:date_time]
+      # Specific time event
+      time = Time.parse(datetime_info[:date_time])
+      time.strftime("%Y-%m-%d %H:%M")
+    else
+      "Unknown"
+    end
+  end
+end
+
+if __FILE__ == $0
+  MCPServer.new.run
+end

data/lib/utilities/slack/README.md

@@ -0,0 +1,211 @@
+# Slack MCP Server
+
+A Ruby-based Model Context Protocol (MCP) server that provides programmatic access to Slack's Web API. This server can operate in two modes:
+
+1. **CLI script**: Direct command-line usage for posting messages to channels
+2. **MCP server**: Integration with AI assistants like Claude Code
+
+## Features
+
+- 💬 **Post messages** to Slack channels with optional custom usernames
+- 📋 **List channels** to see available public and private channels
+- 🔐 **Bot token authentication** with secure credential storage
+- 🛡️ **Error handling** with comprehensive API failure reporting
+- ✅ **Connection testing** to verify authentication before operations
+
+## Prerequisites
+
+### 1. Ruby Environment
+
+```bash
+# Install Ruby dependencies
+bundle install
+```
+
+Required gems:
+- `slack-ruby-client` - Slack Web API client
+- `standard` - Ruby code linting
+
+### 2. Slack App Setup
+
+#### Step 1: Create a Slack App
+
+1. Go to https://api.slack.com/apps
+2. Click **"Create New App"** → **"From scratch"**
+3. Give your app a name and select your workspace
+4. Note your app's details
+
+#### Step 2: Configure OAuth Permissions
+
+1. Go to **"OAuth & Permissions"** in the sidebar
+2. Under **"Scopes"** → **"Bot Token Scopes"**, add these permissions:
+   - `chat:write` - Required to post messages
+   - `channels:read` - Optional, for listing public channels
+   - `groups:read` - Optional, for listing private channels
+3. Click **"Install to Workspace"** at the top
+4. Copy the **"Bot User OAuth Token"** (starts with `xoxb-`)
+
+#### Step 3: Configure Credentials
+
+Configure your Slack bot token using the gem's configuration system:
+
+```bash
+mcpz slack set_bot_token xoxb-your-actual-slack-token
+```
+
+This will store your bot token securely in `~/.config/mcpeasy/slack.json`.
+
+## Usage
+
+### CLI Mode
+
+#### Test Connection
+```bash
+mcpz slack test
+```
+
+#### Post Messages
+```bash
+# Post a simple message
+mcpz slack post general "Hello from Ruby!"
+
+# Post with a custom username
+mcpz slack post general "Deployment completed successfully!" --username "DeployBot"
+
+# Use channel with or without # prefix
+mcpz slack post "#general" "Message with # prefix"
+```
+
+#### List Channels
+```bash
+# List all available channels
+mcpz slack channels
+```
+
+### MCP Server Mode
+
+#### Configuration for Claude Code
+
+Add to your `.mcp.json` configuration:
+
+```json
+{
+  "mcpServers": {
+    "slack": {
+      "command": "mcpz",
+      "args": ["slack", "mcp"]
+    }
+  }
+}
+```
+
+#### Run as Standalone MCP Server
+
+```bash
+mcpz slack mcp
+```
+
+The server provides these tools to Claude Code:
+
+- **test_connection**: Test Slack API connectivity
+- **post_message**: Post messages to channels with optional custom username
+- **list_channels**: List available public and private channels
+
+## Security & Permissions
+
+### Required OAuth Scopes
+
+- `chat:write` - Required to post messages
+- `channels:read` - Optional, for listing public channels  
+- `groups:read` - Optional, for listing private channels
+
+### Local File Storage
+
+- **Credentials**: Stored in `~/.config/mcpeasy/slack.json`
+- **Logs**: Application logs for debugging
+
+### Best Practices
+
+1. **Never commit** bot tokens to version control
+2. **Limit permissions** to only what's needed for your use case
+3. **Regular rotation** of bot tokens (recommended annually)
+4. **Monitor usage** through Slack's app management dashboard
+
+## Troubleshooting
+
+### Common Issues
+
+#### "Invalid auth" Error
+- Check that your bot token is correct and starts with `xoxb-`
+- Re-run: `mcpz slack set_bot_token xoxb-your-actual-slack-token`
+- Verify the token hasn't expired or been revoked
+- Ensure the app is installed in your workspace
+
+#### "Missing scope" Error
+- Add the required OAuth scopes in your Slack app configuration
+- Reinstall the app to workspace after adding scopes
+- Required scopes: `chat:write` (minimum), `channels:read`, `groups:read` (optional)
+
+#### "Channel not found" Error
+- Verify the channel name is spelled correctly
+- Ensure your bot has access to the channel (invite the bot if needed)
+- Try using the channel ID instead of the name
+
+#### "Bot not in channel" Error
+- Invite your bot to the channel: `/invite @your-bot-name`
+- Or use channels where the bot is already a member
+
+### Testing the Setup
+
+1. **Test CLI authentication**:
+   ```bash
+   mcpz slack test
+   ```
+
+2. **Test MCP server**:
+   ```bash
+   echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | mcpz slack mcp
+   ```
+
+## Development
+
+### File Structure
+
+```
+lib/utilities/slack/
+├── cli.rb          # Thor-based CLI interface
+├── mcp.rb          # MCP server implementation  
+├── slack_tool.rb   # Slack Web API wrapper
+└── README.md       # This file
+```
+
+### Adding New Features
+
+1. **New API methods**: Add to `SlackTool` class
+2. **New CLI commands**: Add to `SlackCLI` class  
+3. **New MCP tools**: Add to `MCPServer` class
+
+### Testing
+
+```bash
+# Run Ruby linting
+bundle exec standardrb
+
+# Test CLI commands
+mcpz slack test
+mcpz slack channels
+
+# Test MCP server manually
+echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | mcpz slack mcp
+```
+
+## Contributing
+
+1. Follow existing code patterns and style
+2. Add comprehensive error handling
+3. Update this README for new features
+4. Test both CLI and MCP modes
+
+## License
+
+This project follows the same license as the parent repository.