mcpeasy 0.1.0

data/lib/utilities/gcal/gcal_tool.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "google/apis/calendar_v3"
+require "googleauth"
+require "signet/oauth_2/client"
+require "fileutils"
+require "json"
+require "time"
+require_relative "../_google/auth_server"
+require_relative "../../mcpeasy/config"
+
+class GcalTool
+  SCOPES = [
+    "https://www.googleapis.com/auth/calendar.readonly",
+    "https://www.googleapis.com/auth/drive.readonly"
+  ]
+  SCOPE = SCOPES.join(" ")
+
+  def initialize(skip_auth: false)
+    ensure_env!
+    @service = Google::Apis::CalendarV3::CalendarService.new
+    @service.authorization = authorize unless skip_auth
+  end
+
+  def list_events(start_date: nil, end_date: nil, max_results: 20, calendar_id: "primary")
+    # Default to today if no start date provided
+    start_time = start_date ? Time.parse("#{start_date} 00:00:00") : Time.now.beginning_of_day
+    # Default to 7 days from start if no end date provided
+    end_time = end_date ? Time.parse("#{end_date} 23:59:59") : start_time + 7 * 24 * 60 * 60
+
+    results = @service.list_events(
+      calendar_id,
+      max_results: max_results,
+      single_events: true,
+      order_by: "startTime",
+      time_min: start_time.utc.iso8601,
+      time_max: end_time.utc.iso8601
+    )
+
+    events = results.items.map do |event|
+      {
+        id: event.id,
+        summary: event.summary,
+        description: event.description,
+        location: event.location,
+        start: format_event_time(event.start),
+        end: format_event_time(event.end),
+        attendees: format_attendees(event.attendees),
+        html_link: event.html_link,
+        calendar_id: calendar_id
+      }
+    end
+
+    {events: events, count: events.length}
+  rescue Google::Apis::Error => e
+    raise "Google Calendar API Error: #{e.message}"
+  rescue => e
+    log_error("list_events", e)
+    raise e
+  end
+
+  def list_calendars
+    results = @service.list_calendar_lists
+
+    calendars = results.items.map do |calendar|
+      {
+        id: calendar.id,
+        summary: calendar.summary,
+        description: calendar.description,
+        time_zone: calendar.time_zone,
+        access_role: calendar.access_role,
+        primary: calendar.primary
+      }
+    end
+
+    {calendars: calendars, count: calendars.length}
+  rescue Google::Apis::Error => e
+    raise "Google Calendar API Error: #{e.message}"
+  rescue => e
+    log_error("list_calendars", e)
+    raise e
+  end
+
+  def search_events(query, start_date: nil, end_date: nil, max_results: 10)
+    # Default to today if no start date provided
+    start_time = start_date ? Time.parse("#{start_date} 00:00:00") : Time.now.beginning_of_day
+    # Default to 30 days from start if no end date provided
+    end_time = end_date ? Time.parse("#{end_date} 23:59:59") : start_time + 30 * 24 * 60 * 60
+
+    results = @service.list_events(
+      "primary",
+      q: query,
+      max_results: max_results,
+      single_events: true,
+      order_by: "startTime",
+      time_min: start_time.utc.iso8601,
+      time_max: end_time.utc.iso8601
+    )
+
+    events = results.items.map do |event|
+      {
+        id: event.id,
+        summary: event.summary,
+        description: event.description,
+        location: event.location,
+        start: format_event_time(event.start),
+        end: format_event_time(event.end),
+        attendees: format_attendees(event.attendees),
+        html_link: event.html_link,
+        calendar_id: "primary"
+      }
+    end
+
+    {events: events, count: events.length}
+  rescue Google::Apis::Error => e
+    raise "Google Calendar API Error: #{e.message}"
+  rescue => e
+    log_error("search_events", e)
+    raise e
+  end
+
+  def test_connection
+    calendar = @service.get_calendar("primary")
+    {
+      ok: true,
+      user: calendar.summary,
+      email: calendar.id
+    }
+  rescue Google::Apis::Error => e
+    raise "Google Calendar API Error: #{e.message}"
+  rescue => e
+    log_error("test_connection", e)
+    raise e
+  end
+
+  def authenticate
+    perform_auth_flow
+    {success: true}
+  rescue => e
+    {success: false, error: e.message}
+  end
+
+  def perform_auth_flow
+    client_id = Mcpeasy::Config.google_client_id
+    client_secret = Mcpeasy::Config.google_client_secret
+
+    unless client_id && client_secret
+      raise "Google credentials not found. Please save your credentials.json file using: mcpz config set_google_credentials <path_to_credentials.json>"
+    end
+
+    # Create credentials using OAuth2 flow with localhost redirect
+    redirect_uri = "http://localhost:8080"
+    client = Signet::OAuth2::Client.new(
+      client_id: client_id,
+      client_secret: client_secret,
+      scope: SCOPE,
+      redirect_uri: redirect_uri,
+      authorization_uri: "https://accounts.google.com/o/oauth2/auth",
+      token_credential_uri: "https://oauth2.googleapis.com/token"
+    )
+
+    # Generate authorization URL
+    url = client.authorization_uri.to_s
+
+    puts "DEBUG: Client ID: #{client_id[0..20]}..."
+    puts "DEBUG: Scope: #{SCOPE}"
+    puts "DEBUG: Redirect URI: #{redirect_uri}"
+    puts
+
+    # Start callback server to capture OAuth code
+    puts "Starting temporary web server to capture OAuth callback..."
+    puts "Opening authorization URL in your default browser..."
+    puts url
+    puts
+
+    # Automatically open URL in default browser on macOS/Unix
+    if system("which open > /dev/null 2>&1")
+      system("open", url)
+    else
+      puts "Could not automatically open browser. Please copy the URL above manually."
+    end
+    puts
+    puts "Waiting for OAuth callback... (will timeout in 60 seconds)"
+
+    # Wait for the authorization code with timeout
+    code = GoogleAuthServer.capture_auth_code
+
+    unless code
+      raise "Failed to receive authorization code. Please try again."
+    end
+
+    puts "✅ Authorization code received!"
+    client.code = code
+    client.fetch_access_token!
+
+    # Save credentials to config
+    credentials_data = {
+      client_id: client.client_id,
+      client_secret: client.client_secret,
+      scope: client.scope,
+      refresh_token: client.refresh_token,
+      access_token: client.access_token,
+      expires_at: client.expires_at
+    }
+
+    Mcpeasy::Config.save_google_token(credentials_data)
+    puts "✅ Authentication successful! Token saved to config"
+
+    client
+  rescue => e
+    log_error("perform_auth_flow", e)
+    raise "Authentication flow failed: #{e.message}"
+  end
+
+  private
+
+  def authorize
+    credentials_data = Mcpeasy::Config.google_token
+    unless credentials_data
+      raise <<~ERROR
+        Google Calendar authentication required!
+        Run the auth command first:
+        mcpz gcal auth
+      ERROR
+    end
+
+    client = Signet::OAuth2::Client.new(
+      client_id: credentials_data.client_id,
+      client_secret: credentials_data.client_secret,
+      scope: credentials_data.scope.respond_to?(:to_a) ? credentials_data.scope.to_a.join(" ") : credentials_data.scope.to_s,
+      refresh_token: credentials_data.refresh_token,
+      access_token: credentials_data.access_token,
+      token_credential_uri: "https://oauth2.googleapis.com/token"
+    )
+
+    # Check if token needs refresh
+    if credentials_data.expires_at
+      expires_at = if credentials_data.expires_at.is_a?(String)
+        Time.parse(credentials_data.expires_at)
+      else
+        Time.at(credentials_data.expires_at)
+      end
+
+      if Time.now >= expires_at
+        client.refresh!
+        # Update saved credentials with new access token
+        updated_data = {
+          client_id: credentials_data.client_id,
+          client_secret: credentials_data.client_secret,
+          scope: credentials_data.scope.respond_to?(:to_a) ? credentials_data.scope.to_a.join(" ") : credentials_data.scope.to_s,
+          refresh_token: credentials_data.refresh_token,
+          access_token: client.access_token,
+          expires_at: client.expires_at
+        }
+        Mcpeasy::Config.save_google_token(updated_data)
+      end
+    end
+
+    client
+  rescue JSON::ParserError
+    raise "Invalid token data. Please re-run: mcpz gcal auth"
+  rescue => e
+    log_error("authorize", e)
+    raise "Authentication failed: #{e.message}"
+  end
+
+  def ensure_env!
+    unless Mcpeasy::Config.google_client_id && Mcpeasy::Config.google_client_secret
+      raise <<~ERROR
+        Google API credentials not configured!
+        Please save your Google credentials.json file using:
+        mcpz config set_google_credentials <path_to_credentials.json>
+      ERROR
+    end
+  end
+
+  def format_event_time(event_time)
+    return nil unless event_time
+
+    if event_time.date
+      # All-day event
+      {date: event_time.date}
+    elsif event_time.date_time
+      # Specific time event
+      {date_time: event_time.date_time.iso8601}
+    else
+      nil
+    end
+  end
+
+  def format_attendees(attendees)
+    return [] unless attendees
+
+    attendees.map do |attendee|
+      attendee.email
+    end.compact
+  end
+
+  def log_error(method, error)
+    Mcpeasy::Config.ensure_config_dirs
+    File.write(
+      Mcpeasy::Config.log_file_path("gcal", "error"),
+      "#{Time.now}: #{method} error: #{error.class}: #{error.message}\n#{error.backtrace.join("\n")}\n",
+      mode: "a"
+    )
+  end
+end

data/lib/utilities/gcal/mcp.rb

@@ -0,0 +1,381 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "json"
+require_relative "gcal_tool"
+
+class MCPServer
+  def initialize
+    @tools = {
+      "test_connection" => {
+        name: "test_connection",
+        description: "Test the Google Calendar API connection",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      "list_events" => {
+        name: "list_events",
+        description: "List calendar events 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 events to return (default: 20)"
+            },
+            calendar_id: {
+              type: "string",
+              description: "Calendar ID to list events from (default: primary calendar)"
+            }
+          },
+          required: []
+        }
+      },
+      "list_calendars" => {
+        name: "list_calendars",
+        description: "List available calendars",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      "search_events" => {
+        name: "search_events",
+        description: "Search for events by text content",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query to find events"
+            },
+            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 events to return (default: 10)"
+            }
+          },
+          required: ["query"]
+        }
+      }
+    }
+  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("gcal", "startup"), "#{Time.now}: Google Calendar 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("gcal", "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("gcal", "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: "gcal-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("gcal", "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)
+    case tool_name
+    when "test_connection"
+      test_connection
+    when "list_events"
+      list_events(arguments)
+    when "list_calendars"
+      list_calendars(arguments)
+    when "search_events"
+      search_events(arguments)
+    else
+      raise "Unknown tool: #{tool_name}"
+    end
+  end
+
+  def test_connection
+    tool = GcalTool.new
+    response = 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_events(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"
+
+    tool = GcalTool.new
+    result = tool.list_events(
+      start_date: start_date,
+      end_date: end_date,
+      max_results: max_results,
+      calendar_id: calendar_id
+    )
+    events = result[:events]
+
+    if events.empty?
+      "📅 No events found for the specified date range"
+    else
+      output = "📅 Found #{result[:count]} event(s):\n\n"
+      events.each_with_index do |event, index|
+        output << "#{index + 1}. **#{event[:summary] || "No title"}**\n"
+        output << "   - Start: #{format_datetime(event[:start])}\n"
+        output << "   - End: #{format_datetime(event[:end])}\n"
+        output << "   - Description: #{event[:description] || "No description"}\n" if event[:description]
+        output << "   - Location: #{event[:location]}\n" if event[:location]
+        output << "   - Attendees: #{event[:attendees].join(", ")}\n" if event[:attendees]&.any?
+        output << "   - Link: #{event[:html_link]}\n\n"
+      end
+      output
+    end
+  end
+
+  def list_calendars(arguments)
+    tool = GcalTool.new
+    result = tool.list_calendars
+    calendars = result[:calendars]
+
+    if calendars.empty?
+      "📋 No calendars found"
+    else
+      output = "📋 Found #{result[:count]} calendar(s):\n\n"
+      calendars.each_with_index do |calendar, index|
+        output << "#{index + 1}. **#{calendar[:summary]}**\n"
+        output << "   - ID: `#{calendar[:id]}`\n"
+        output << "   - Description: #{calendar[:description]}\n" if calendar[:description]
+        output << "   - Time Zone: #{calendar[:time_zone]}\n"
+        output << "   - Access Role: #{calendar[:access_role]}\n"
+        output << "   - Primary: Yes\n" if calendar[:primary]
+        output << "\n"
+      end
+      output
+    end
+  end
+
+  def search_events(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
+
+    tool = GcalTool.new
+    result = tool.search_events(
+      query,
+      start_date: start_date,
+      end_date: end_date,
+      max_results: max_results
+    )
+    events = result[:events]
+
+    if events.empty?
+      "🔍 No events found matching '#{query}'"
+    else
+      output = "🔍 Found #{result[:count]} event(s) matching '#{query}':\n\n"
+      events.each_with_index do |event, index|
+        output << "#{index + 1}. **#{event[:summary] || "No title"}**\n"
+        output << "   - Start: #{format_datetime(event[:start])}\n"
+        output << "   - End: #{format_datetime(event[:end])}\n"
+        output << "   - Description: #{event[:description] || "No description"}\n" if event[:description]
+        output << "   - Location: #{event[:location]}\n" if event[:location]
+        output << "   - Calendar: #{event[:calendar_id]}\n"
+        output << "   - Link: #{event[:html_link]}\n\n"
+      end
+      output
+    end
+  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