mcpeasy 0.1.0

data/lib/utilities/gdrive/mcp.rb

@@ -0,0 +1,347 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "json"
+require_relative "gdrive_tool"
+
+class MCPServer
+  def initialize
+    @tools = {
+      "test_connection" => {
+        name: "test_connection",
+        description: "Test the Google Drive API connection",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      "search_files" => {
+        name: "search_files",
+        description: "Search for files in Google Drive by content or name",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query to find files"
+            },
+            max_results: {
+              type: "number",
+              description: "Maximum number of results to return (default: 10)"
+            }
+          },
+          required: ["query"]
+        }
+      },
+      "get_file_content" => {
+        name: "get_file_content",
+        description: "Get the content of a specific Google Drive file",
+        inputSchema: {
+          type: "object",
+          properties: {
+            file_id: {
+              type: "string",
+              description: "The Google Drive file ID"
+            }
+          },
+          required: ["file_id"]
+        }
+      },
+      "list_files" => {
+        name: "list_files",
+        description: "List recent files in Google Drive",
+        inputSchema: {
+          type: "object",
+          properties: {
+            max_results: {
+              type: "number",
+              description: "Maximum number of files to return (default: 20)"
+            }
+          },
+          required: []
+        }
+      }
+    }
+  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("gdrive", "startup"), "#{Time.now}: Google Drive 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("gdrive", "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("gdrive", "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: "gdrive-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("gdrive", "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 GdriveTool only when needed
+    @gdrive_tool ||= GdriveTool.new
+
+    case tool_name
+    when "test_connection"
+      test_connection
+    when "search_files"
+      search_files(arguments)
+    when "get_file_content"
+      get_file_content(arguments)
+    when "list_files"
+      list_files(arguments)
+    else
+      raise "Unknown tool: #{tool_name}"
+    end
+  end
+
+  def test_connection
+    tool = GdriveTool.new
+    response = tool.test_connection
+    if response[:ok]
+      "✅ Successfully connected to Google Drive.\n" \
+      "   User: #{response[:user]} (#{response[:email]})\n" \
+      "   Storage: #{format_bytes(response[:storage_used])} / #{format_bytes(response[:storage_limit])}"
+    else
+      raise "Connection test failed"
+    end
+  end
+
+  def search_files(arguments)
+    unless arguments["query"]
+      raise "Missing required argument: query"
+    end
+
+    query = arguments["query"].to_s
+    max_results = arguments["max_results"]&.to_i || 10
+
+    tool = GdriveTool.new
+    result = tool.search_files(query, max_results: max_results)
+    files = result[:files]
+
+    if files.empty?
+      "🔍 No files found matching '#{query}'"
+    else
+      output = "🔍 Found #{result[:count]} file(s) matching '#{query}':\n\n"
+      files.each_with_index do |file, index|
+        output << "#{index + 1}. **#{file[:name]}**\n"
+        output << "   - ID: `#{file[:id]}`\n"
+        output << "   - Type: #{file[:mime_type]}\n"
+        output << "   - Size: #{format_bytes(file[:size])}\n"
+        output << "   - Modified: #{file[:modified_time]}\n"
+        output << "   - Link: #{file[:web_view_link]}\n\n"
+      end
+      output
+    end
+  end
+
+  def get_file_content(arguments)
+    unless arguments["file_id"]
+      raise "Missing required argument: file_id"
+    end
+
+    file_id = arguments["file_id"].to_s
+    tool = GdriveTool.new
+    result = tool.get_file_content(file_id)
+
+    output = "📄 **#{result[:name]}**\n"
+    output << "   - Type: #{result[:mime_type]}\n"
+    output << "   - Size: #{format_bytes(result[:size])}\n\n"
+    output << "**Content:**\n"
+    output << "```\n#{result[:content]}\n```"
+    output
+  end
+
+  def list_files(arguments)
+    max_results = arguments["max_results"]&.to_i || 20
+    tool = GdriveTool.new
+    result = tool.list_files(max_results: max_results)
+    files = result[:files]
+
+    if files.empty?
+      "📂 No files found in Google Drive"
+    else
+      output = "📂 Recent #{result[:count]} file(s):\n\n"
+      files.each_with_index do |file, index|
+        output << "#{index + 1}. **#{file[:name]}**\n"
+        output << "   - ID: `#{file[:id]}`\n"
+        output << "   - Type: #{file[:mime_type]}\n"
+        output << "   - Size: #{format_bytes(file[:size])}\n"
+        output << "   - Modified: #{file[:modified_time]}\n"
+        output << "   - Link: #{file[:web_view_link]}\n\n"
+      end
+      output
+    end
+  end
+
+  private
+
+  def format_bytes(bytes)
+    return "Unknown" unless bytes
+
+    units = %w[B KB MB GB TB]
+    size = bytes.to_f
+    unit_index = 0
+
+    while size >= 1024 && unit_index < units.length - 1
+      size /= 1024
+      unit_index += 1
+    end
+
+    "#{size.round(1)} #{units[unit_index]}"
+  end
+end
+
+if __FILE__ == $0
+  MCPServer.new.run
+end

data/lib/utilities/gmeet/README.md

@@ -0,0 +1,133 @@
+# Google Meet MCP Server
+
+A Model Context Protocol (MCP) server for Google Meet integration. This tool allows you to list, search, and get direct links to Google Meet meetings from your Google Calendar.
+
+## Features
+
+- **List Google Meet meetings** with date filtering
+- **Search for meetings** by title or description
+- **Get upcoming meetings** in the next 24 hours
+- **Extract Google Meet URLs** for direct browser access
+- **CLI and MCP server modes** for flexible usage
+
+## Setup
+
+### 1. Google API Credentials
+
+1. Go to the [Google Cloud Console](https://console.cloud.google.com/)
+2. Create a new project or select an existing one
+3. Enable the Google Calendar API
+4. Create credentials (OAuth 2.0 Client ID) for a "Desktop application"
+5. Download the credentials and note the Client ID and Client Secret
+
+### 2. OAuth Credentials Setup
+
+The Google OAuth credentials will be configured during the authentication process. You'll need the Client ID and Client Secret from your Google Cloud Console setup.
+
+### 3. Install Dependencies
+
+```bash
+bundle install
+```
+
+### 4. Authentication
+
+Run the authentication flow to get access to your Google Calendar:
+
+```bash
+mcpz google auth
+```
+
+This will open a browser for Google OAuth authorization and save credentials to `~/.config/mcpeasy/google/token.json`. The credentials are shared with all Google services.
+
+## Usage
+
+### CLI Mode
+
+**Test connection:**
+```bash
+mcpz gmeet test
+```
+
+**List Google Meet meetings:**
+```bash
+mcpz gmeet meetings
+mcpz gmeet meetings --start_date 2024-01-01 --end_date 2024-01-07
+mcpz gmeet meetings --max_results 10
+```
+
+**List upcoming meetings:**
+```bash
+mcpz gmeet upcoming
+mcpz gmeet upcoming --max_results 5
+```
+
+**Search for meetings:**
+```bash
+mcpz gmeet search "standup"
+mcpz gmeet search "team meeting" --start_date 2024-01-01
+```
+
+**Get meeting URL by event ID:**
+```bash
+mcpz gmeet url event_id_here
+```
+
+### MCP Server Mode
+
+Configure in your `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "gmeet": {
+      "command": "mcpz",
+      "args": ["gmeet", "mcp"]
+    }
+  }
+}
+```
+
+Available MCP tools:
+- `test_connection` - Test Google Calendar API connection
+- `list_meetings` - List Google Meet meetings with date filtering
+- `upcoming_meetings` - List upcoming meetings in next 24 hours
+- `search_meetings` - Search meetings by text content
+- `get_meeting_url` - Get Google Meet URL for specific event
+
+## How It Works
+
+The tool uses the Google Calendar API to:
+
+1. **Fetch calendar events** from your Google Calendar
+2. **Filter for Google Meet meetings** by detecting:
+   - Conference data with Google Meet
+   - Hangout links (legacy)
+   - Meet.google.com URLs in descriptions
+   - Meet.google.com URLs in location fields
+3. **Extract meeting URLs** for direct browser access
+4. **Format and present** meeting information
+
+## Troubleshooting
+
+**Authentication Issues:**
+- Re-run the auth flow: `mcpz google auth`
+- Check that the Google Calendar API is enabled in your Google Cloud project
+- Verify your Google OAuth credentials are configured correctly
+
+**No meetings found:**
+- Verify you have Google Meet meetings in your calendar
+- Check the date range (default is 7 days from today)
+- Ensure meetings have Google Meet links attached
+
+**MCP Server Issues:**
+- Check logs in `./logs/mcp_gmeet_error.log`
+- Verify the server path in `.mcp.json` is correct
+- Ensure all dependencies are installed with `bundle install`
+
+## API Permissions
+
+This tool requires:
+- `https://www.googleapis.com/auth/calendar.readonly` - Read access to your Google Calendar
+
+The tool only reads calendar data and never modifies your calendar or meetings.

data/lib/utilities/gmeet/cli.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "thor"
+require_relative "gmeet_tool"
+
+class GmeetCLI < Thor
+  desc "test", "Test the Google Calendar API connection"
+  def test
+    response = tool.test_connection
+
+    if response[:ok]
+      puts "✅ Successfully connected to Google Calendar"
+      puts "   User: #{response[:user]} (#{response[:email]})"
+    else
+      warn "❌ Connection test failed"
+    end
+  rescue RuntimeError => e
+    puts "❌ Failed to connect to Google Calendar: #{e.message}"
+    exit 1
+  end
+
+  desc "meetings", "List Google Meet meetings"
+  method_option :start_date, type: :string, aliases: "-s", desc: "Start date (YYYY-MM-DD)"
+  method_option :end_date, type: :string, aliases: "-e", desc: "End date (YYYY-MM-DD)"
+  method_option :max_results, type: :numeric, default: 20, aliases: "-n", desc: "Max number of meetings"
+  method_option :calendar_id, type: :string, aliases: "-c", desc: "Calendar ID (default: primary)"
+  def meetings
+    result = tool.list_meetings(
+      start_date: options[:start_date],
+      end_date: options[:end_date],
+      max_results: options[:max_results],
+      calendar_id: options[:calendar_id] || "primary"
+    )
+    meetings = result[:meetings]
+
+    if meetings.empty?
+      puts "🎥 No Google Meet meetings found for the specified date range"
+    else
+      puts "🎥 Found #{result[:count]} Google Meet meeting(s):"
+      meetings.each_with_index do |meeting, index|
+        puts "   #{index + 1}. #{meeting[:summary] || "No title"}"
+        puts "      Start: #{format_datetime(meeting[:start])}"
+        puts "      End: #{format_datetime(meeting[:end])}"
+        puts "      Description: #{meeting[:description]}" if meeting[:description]
+        puts "      Location: #{meeting[:location]}" if meeting[:location]
+        puts "      Attendees: #{meeting[:attendees].join(", ")}" if meeting[:attendees]&.any?
+        puts "      Meet Link: #{meeting[:meet_link]}"
+        puts "      Calendar Link: #{meeting[:html_link]}"
+        puts
+      end
+    end
+  rescue RuntimeError => e
+    warn "❌ Failed to list meetings: #{e.message}"
+    exit 1
+  end
+
+  desc "upcoming", "List upcoming Google Meet meetings"
+  method_option :max_results, type: :numeric, default: 10, aliases: "-n", desc: "Max number of meetings"
+  method_option :calendar_id, type: :string, aliases: "-c", desc: "Calendar ID (default: primary)"
+  def upcoming
+    result = tool.upcoming_meetings(
+      max_results: options[:max_results],
+      calendar_id: options[:calendar_id] || "primary"
+    )
+    meetings = result[:meetings]
+
+    if meetings.empty?
+      puts "🎥 No upcoming Google Meet meetings found in the next 24 hours"
+    else
+      puts "🎥 Found #{result[:count]} upcoming Google Meet meeting(s):"
+      meetings.each_with_index do |meeting, index|
+        puts "   #{index + 1}. #{meeting[:summary] || "No title"}"
+        puts "      Start: #{format_datetime(meeting[:start])} (#{meeting[:time_until_start]})"
+        puts "      End: #{format_datetime(meeting[:end])}"
+        puts "      Description: #{meeting[:description]}" if meeting[:description]
+        puts "      Location: #{meeting[:location]}" if meeting[:location]
+        puts "      Attendees: #{meeting[:attendees].join(", ")}" if meeting[:attendees]&.any?
+        puts "      Meet Link: #{meeting[:meet_link]}"
+        puts "      Calendar Link: #{meeting[:html_link]}"
+        puts
+      end
+    end
+  rescue RuntimeError => e
+    warn "❌ Failed to list upcoming meetings: #{e.message}"
+    exit 1
+  end
+
+  desc "search QUERY", "Search for Google Meet meetings by text content"
+  method_option :start_date, type: :string, aliases: "-s", desc: "Start date (YYYY-MM-DD)"
+  method_option :end_date, type: :string, aliases: "-e", desc: "End date (YYYY-MM-DD)"
+  method_option :max_results, type: :numeric, default: 10, aliases: "-n", desc: "Max number of meetings"
+  def search(query)
+    result = tool.search_meetings(
+      query,
+      start_date: options[:start_date],
+      end_date: options[:end_date],
+      max_results: options[:max_results]
+    )
+    meetings = result[:meetings]
+
+    if meetings.empty?
+      puts "🔍 No Google Meet meetings found matching '#{query}'"
+    else
+      puts "🔍 Found #{result[:count]} Google Meet meeting(s) matching '#{query}':"
+      meetings.each_with_index do |meeting, index|
+        puts "   #{index + 1}. #{meeting[:summary] || "No title"}"
+        puts "      Start: #{format_datetime(meeting[:start])}"
+        puts "      End: #{format_datetime(meeting[:end])}"
+        puts "      Description: #{meeting[:description]}" if meeting[:description]
+        puts "      Location: #{meeting[:location]}" if meeting[:location]
+        puts "      Meet Link: #{meeting[:meet_link]}"
+        puts "      Calendar Link: #{meeting[:html_link]}"
+        puts
+      end
+    end
+  rescue RuntimeError => e
+    warn "❌ Failed to search meetings: #{e.message}"
+    exit 1
+  end
+
+  desc "url EVENT_ID", "Get the Google Meet URL for a specific event"
+  method_option :calendar_id, type: :string, aliases: "-c", desc: "Calendar ID (default: primary)"
+  def url(event_id)
+    result = tool.get_meeting_url(event_id, calendar_id: options[:calendar_id] || "primary")
+
+    puts "🎥 #{result[:summary] || "Meeting"}"
+    puts "   Start: #{format_datetime(result[:start])}"
+    puts "   End: #{format_datetime(result[:end])}"
+    puts "   Meet Link: #{result[:meet_link]}"
+    puts "   Event ID: #{result[:event_id]}"
+  rescue RuntimeError => e
+    warn "❌ Failed to get meeting URL: #{e.message}"
+    exit 1
+  end
+
+  private
+
+  def tool
+    @tool ||= GmeetTool.new
+  end
+
+  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