mcpeasy 0.1.0

data/lib/utilities/slack/cli.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "thor"
+require_relative "slack_tool"
+
+class SlackCLI < Thor
+  desc "test", "Test the Slack API connection"
+  def test
+    response = tool.test_connection
+
+    if response["ok"]
+      puts "✅ Successfully connected to Slack"
+      puts "   Bot name: #{response["user"]}"
+      puts "   Team: #{response["team"]}"
+    else
+      warn "❌ Authentication failed: #{response["error"]}"
+    end
+  rescue RuntimeError => e
+    puts "❌ Failed to connect to Slack: #{e.message}"
+    exit 1
+  end
+
+  desc "list", "List available Slack channels"
+  def list
+    channels = tool.list_channels
+
+    if channels && !channels.empty?
+      puts "📋 Available channels:"
+      channels.each do |channel|
+        puts "   ##{channel[:name]} (ID: #{channel[:id]})"
+      end
+    end
+  rescue RuntimeError => e
+    warn "❌ Failed to list channels: #{e.message}"
+    exit 1
+  end
+
+  desc "post", "Post a message to a Slack channel"
+  method_option :channel, required: true, type: :string, aliases: "-c"
+  method_option :message, required: true, type: :string, aliases: "-m"
+  method_option :username, type: :string, aliases: "-u"
+  method_option :timestamp, type: :string, aliases: "-t"
+  def post
+    channel = options[:channel]
+    text = options[:message]
+    username = options[:username]
+    thread_ts = options[:timestamp]
+
+    response = tool.post_message(
+      channel: channel,
+      text: text,
+      username: username,
+      thread_ts: thread_ts
+    )
+
+    if response["ok"]
+      puts "✅ Message posted successfully to ##{channel}"
+      puts "   Message timestamp: #{response["ts"]}"
+    else
+      warn "❌ Failed to post message: #{response["error"]}"
+      exit 1
+    end
+  rescue RuntimeError => e
+    warn "❌ Unexpected error: #{e.message}"
+    exit 1
+  end
+
+  private
+
+  def tool
+    @tool ||= SlackTool.new
+  end
+end

data/lib/utilities/slack/mcp.rb

@@ -0,0 +1,280 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "json"
+require_relative "slack_tool"
+
+class MCPServer
+  def initialize
+    # Defer SlackTool initialization until actually needed
+    @slack_tool = nil
+    @tools = {
+      "test_connection" => {
+        name: "test_connection",
+        description: "Test the Slack API connection",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      "list_channels" => {
+        name: "list_channels",
+        description: "List available Slack channels",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      "post_message" => {
+        name: "post_message",
+        description: "Post a message to a Slack channel",
+        inputSchema: {
+          type: "object",
+          properties: {
+            channel: {
+              type: "string",
+              description: "The Slack channel name (with or without #)"
+            },
+            text: {
+              type: "string",
+              description: "The message text to post"
+            },
+            username: {
+              type: "string",
+              description: "Optional custom username for the message"
+            },
+            thread_ts: {
+              type: "string",
+              description: "Optional timestamp of parent message to reply to"
+            }
+          },
+          required: ["channel", "text"]
+        }
+      }
+    }
+  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("slack", "startup"), "#{Time.now}: Slack 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("slack", "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("slack", "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: "slack-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("slack", "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 SlackTool only when needed
+    @slack_tool ||= SlackTool.new
+
+    case tool_name
+    when "test_connection"
+      test_connection
+    when "list_channels"
+      list_channels
+    when "post_message"
+      post_message(arguments)
+    else
+      raise "Unknown tool: #{tool_name}"
+    end
+  end
+
+  def test_connection
+    response = @slack_tool.test_connection
+    if response["ok"]
+      "✅ Successfully connected to Slack. Bot: #{response["user"]}, Team: #{response["team"]}"
+    else
+      raise "Authentication failed: #{response["error"]}"
+    end
+  end
+
+  def list_channels
+    channels = @slack_tool.list_channels
+    output = "📋 #{channels.count} Available channels: "
+    output << channels.map { |c| "##{c[:name]} (ID: #{c[:id]})" }.join(", ")
+    output
+  end
+
+  def post_message(arguments)
+    # Validate required arguments
+    unless arguments["channel"]
+      raise "Missing required argument: channel"
+    end
+    unless arguments["text"]
+      raise "Missing required argument: text"
+    end
+
+    channel = arguments["channel"].to_s.sub(/^#/, "")
+    text = arguments["text"].to_s
+    username = arguments["username"]&.to_s
+    thread_ts = arguments["thread_ts"]&.to_s
+
+    response = @slack_tool.post_message(
+      channel: channel,
+      text: text,
+      username: username&.empty? ? nil : username,
+      thread_ts: thread_ts&.empty? ? nil : thread_ts
+    )
+
+    "✅ Message posted successfully to ##{channel} (Message timestamp: #{response["ts"]})"
+  end
+end
+
+if __FILE__ == $0
+  MCPServer.new.run
+end

data/lib/utilities/slack/slack_tool.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "slack-ruby-client"
+require "mcpeasy/config"
+
+class SlackTool
+  def initialize
+    ensure_env!
+    @client = Slack::Web::Client.new(
+      token: Mcpeasy::Config.slack_bot_token,
+      timeout: 10, # 10 second timeout
+      open_timeout: 5 # 5 second connection timeout
+    )
+  end
+
+  def post_message(channel:, text:, username: nil, thread_ts: nil)
+    # Clean up parameters
+    clean_channel = channel.to_s.sub(/^#/, "").strip
+    clean_text = text.to_s.strip
+
+    # Validate inputs
+    raise "Channel cannot be empty" if clean_channel.empty?
+    raise "Text cannot be empty" if clean_text.empty?
+
+    # Build request parameters
+    params = {
+      channel: clean_channel,
+      text: clean_text
+    }
+    params[:username] = username if username && !username.to_s.strip.empty?
+    params[:thread_ts] = thread_ts if thread_ts && !thread_ts.to_s.strip.empty?
+
+    # Retry logic for reliability
+    max_retries = 3
+    retry_count = 0
+
+    begin
+      response = @client.chat_postMessage(params)
+
+      if response["ok"]
+        response
+      else
+        raise "Failed to post message: #{response["error"]} (#{response.inspect})"
+      end
+    rescue Slack::Web::Api::Errors::TooManyRequestsError => e
+      retry_count += 1
+      if retry_count <= max_retries
+        sleep_time = e.retry_after || 1
+        sleep(sleep_time)
+        retry
+      else
+        raise "Slack API Error: #{e.message}"
+      end
+    rescue Slack::Web::Api::Errors::SlackError => e
+      retry_count += 1
+      if retry_count <= max_retries && retryable_error?(e)
+        sleep(0.5 * retry_count) # Exponential backoff
+        retry
+      else
+        raise "Slack API Error: #{e.message}"
+      end
+    rescue => e
+      Mcpeasy::Config.ensure_config_dirs
+      File.write(Mcpeasy::Config.log_file_path("slack", "error"), "#{Time.now}: SlackTool error: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}\n", mode: "a")
+      raise e
+    end
+  end
+
+  def list_channels
+    response = @client.conversations_list(types: "public_channel,private_channel")
+
+    if response["ok"]
+      response["channels"].to_a.map do |channel|
+        {
+          name: channel["name"],
+          id: channel["id"]
+        }
+      end
+    else
+      raise "Failed to list channels: #{response["error"]}"
+    end
+  rescue Slack::Web::Api::Errors::SlackError => e
+    raise "Slack API Error: #{e.message}"
+  end
+
+  def test_connection
+    response = @client.auth_test
+
+    if response["ok"]
+      response
+    else
+      raise "Authentication failed: #{response["error"]}"
+    end
+  rescue Slack::Web::Api::Errors::SlackError => e
+    raise "Slack API Error: #{e.message}"
+  end
+
+  def tool_definitions
+  end
+
+  private
+
+  def retryable_error?(error)
+    # Network-related errors that might be temporary
+    error.is_a?(Slack::Web::Api::Errors::TimeoutError) ||
+      error.is_a?(Slack::Web::Api::Errors::UnavailableError) ||
+      (error.respond_to?(:message) && error.message.include?("timeout"))
+  end
+
+  def ensure_env!
+    unless Mcpeasy::Config.slack_bot_token
+      raise <<~ERROR
+        Slack bot token is not configured!
+        Please run: mcp set slack_bot_token YOUR_TOKEN
+      ERROR
+    end
+  end
+end

data/mcpeasy.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "lib/mcpeasy/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "mcpeasy"
+  spec.version = Mcpeasy::VERSION
+  spec.authors = ["Joel Helbling"]
+  spec.email = ["joel@joelhelbling.com"]
+
+  spec.summary = "MCP servers made easy"
+  spec.description = "mcpeasy, LM squeezy - Easy-to-use MCP servers for Google Calendar, Google Drive, Google Meet, and Slack"
+  spec.homepage = "https://github.com/joelhelbling/mcpeasy"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/joelhelbling/mcpeasy"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+
+  spec.bindir = "bin"
+  spec.executables = ["mcpz"]
+  spec.require_paths = ["lib"]
+
+  # Dependencies
+  spec.add_dependency "google-apis-calendar_v3", "~> 0.35"
+  spec.add_dependency "google-apis-drive_v3", "~> 0.45"
+  spec.add_dependency "googleauth", "~> 1.8"
+  spec.add_dependency "slack-ruby-client", "~> 2.1"
+  spec.add_dependency "webrick", "~> 1.8"
+  spec.add_dependency "thor", "~> 1.3"
+  spec.add_dependency "mother", "~> 0.1"
+
+  # Development dependencies
+  spec.add_development_dependency "standard", "~> 1.50"
+
+  # Post-install message
+  spec.post_install_message = "mcpeasy installed! Run 'mcpz setup' to configure."
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: mcpeasy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joel Helbling
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-apis-calendar_v3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.35'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.35'
+- !ruby/object:Gem::Dependency
+  name: google-apis-drive_v3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.45'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.45'
+- !ruby/object:Gem::Dependency
+  name: googleauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: slack-ruby-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: mother
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+description: mcpeasy, LM squeezy - Easy-to-use MCP servers for Google Calendar, Google
+  Drive, Google Meet, and Slack
+email:
+- joel@joelhelbling.com
+executables:
+- mcpz
+extensions: []
+extra_rdoc_files: []
+files:
+- ".claude/settings.json"
+- ".claudeignore"
+- ".envrc"
+- ".mcp.json"
+- CLAUDE.md
+- README.md
+- bin/mcpz
+- env.template
+- ext/setup.rb
+- lib/mcpeasy.rb
+- lib/mcpeasy/cli.rb
+- lib/mcpeasy/config.rb
+- lib/mcpeasy/setup.rb
+- lib/mcpeasy/version.rb
+- lib/utilities/_google/auth_server.rb
+- lib/utilities/gcal/README.md
+- lib/utilities/gcal/cli.rb
+- lib/utilities/gcal/gcal_tool.rb
+- lib/utilities/gcal/mcp.rb
+- lib/utilities/gdrive/README.md
+- lib/utilities/gdrive/cli.rb
+- lib/utilities/gdrive/gdrive_tool.rb
+- lib/utilities/gdrive/mcp.rb
+- lib/utilities/gmeet/README.md
+- lib/utilities/gmeet/cli.rb
+- lib/utilities/gmeet/gmeet_tool.rb
+- lib/utilities/gmeet/mcp.rb
+- lib/utilities/slack/README.md
+- lib/utilities/slack/cli.rb
+- lib/utilities/slack/mcp.rb
+- lib/utilities/slack/slack_tool.rb
+- logs/.keep
+- mcpeasy.gemspec
+homepage: https://github.com/joelhelbling/mcpeasy
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/joelhelbling/mcpeasy
+  source_code_uri: https://github.com/joelhelbling/mcpeasy
+post_install_message: mcpeasy installed! Run 'mcpz setup' to configure.
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: MCP servers made easy
+test_files: []