zeromcp 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2e5b203cdc7f03afff0cf6ce507e9480455b3f16e469222d5934af9351ffa9a
-  data.tar.gz: 8e968d22d810a2f25962eb5de0f242438f3ea4359c40cee4616398280695c6f8
+  metadata.gz: aa95cc5fe08e2a54b9034a2248b978e1a01919bd3cb0249f444031e070f0dcd1
+  data.tar.gz: ae4cd9f4405f8b9786f0bf5e238898b8260d5d37b5a8aac9bdd96ac3ae02876a
 SHA512:
-  metadata.gz: b5af7807f278f6430cd65fad75104d90536fbe5c840a2dfce3b7c125415940d65f4166e420f06b085c1ff6fe60c90a525773956e4e341c3b20098258227296a5
-  data.tar.gz: 3c0c7c8350efedaf3bf7ec4342e85f817b6da45e6668d6aace1553ef98edc478143db42acc4652b119a179c7b4580ddef29c54226457d03b3ed88d4582e6bd09
+  metadata.gz: 38b41336ef5617f74cf599c79cb0fd52f872eba7c912825c74020a3026cf8c8e360a1b79ac2f12a612e73cb657e2a2d240a4fed709012796c430990100ddd26f
+  data.tar.gz: b502b28ab22e0666937aeb772818d6bf8739671c4b274b03acec2307652d64830aa37ee7611094405be58de2c9d134ed67a3ed507241cb8615ea6fe3c90d7def

data/README.md

@@ -43,6 +43,11 @@ ZeroMCP doesn't own the HTTP layer. You bring your own framework; ZeroMCP gives
 ```ruby
 require 'sinatra'
 require 'json'
+require_relative 'lib/zeromcp'
+
+config = ZeroMcp::Config.load
+server = ZeroMcp::Server.new(config)
+server.load_tools
 
 post '/mcp' do
   request_body = JSON.parse(request.body.read)
@@ -66,7 +71,7 @@ end
 
 ```sh
 gem build zeromcp.gemspec
-gem install zeromcp-0.1.0.gem
+gem install zeromcp-0.2.2.gem
 ```
 
 ## Sandbox
@@ -99,5 +104,5 @@ tools/
 ## Testing
 
 ```sh
-ruby -I lib -I test -e 'Dir["test/**/*_test.rb"].each { |f| require_relative f }'
+ruby -I lib -I test -e 'Dir["test/**/test_*.rb"].each { |f| require_relative f }'
 ```

data/lib/zeromcp/config.rb

@@ -7,7 +7,7 @@ module ZeroMcp
   class Config
     attr_reader :tools_dir, :resources_dir, :prompts_dir,
                 :separator, :logging, :bypass_permissions, :execute_timeout,
-                :page_size, :icon
+                :page_size, :icon, :title
 
     def initialize(opts = {})
       tools = opts[:tools_dir] || opts['tools'] || './tools'
@@ -28,6 +28,7 @@ module ZeroMcp
       @namespacing = opts[:namespacing] || opts['namespacing'] || {}
       @page_size = opts[:page_size] || opts['page_size'] || 0
       @icon = opts[:icon] || opts['icon']
+      @title = opts[:title] || opts['title'] || 'ZeroMCP'
     end
 
     attr_reader :credentials, :cache_credentials, :namespacing

data/lib/zeromcp/credentials.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ZeroMcp
+  module Credentials
+    module_function
+
+    def resolve(tool_name, config, cache: nil)
+      return nil if config.credentials.empty?
+      config.credentials.each do |ns, source|
+        if tool_name.start_with?("#{ns}_") || tool_name.start_with?("#{ns}#{config.separator}")
+          return resolve_for_ns(ns.to_s, source, config, cache)
+        end
+      end
+      nil
+    end
+
+    def resolve_for_ns(ns, source, config, cache)
+      return resolve_source(source) unless config.cache_credentials
+      return cache[ns] if cache && cache.key?(ns)
+      creds = resolve_source(source)
+      cache[ns] = creds if cache
+      creds
+    end
+
+    def resolve_source(source)
+      source = source.transform_keys(&:to_s) if source.is_a?(Hash)
+      if source['env']
+        val = ENV[source['env']]
+        return nil if val.nil? || val.empty?
+        begin; return JSON.parse(val); rescue; return val; end
+      end
+      if source['file']
+        path = File.expand_path(source['file'])
+        return nil unless File.exist?(path)
+        val = File.read(path).strip
+        begin; return JSON.parse(val); rescue; return val; end
+      end
+      nil
+    end
+  end
+end

data/lib/zeromcp/openapi.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative 'schema'
+
+module ZeroMcp
+  module OpenApi
+    module_function
+
+    def build(tools, config)
+      paths = {}
+
+      tools.each do |_name, tool|
+        next unless tool.route.is_a?(Hash)
+
+        route_method = tool.route_method
+        route_path = tool.route_path
+
+        # Extract :param names from path, convert to {param} for OpenAPI
+        path_param_names = route_path.scan(/:([A-Za-z_][A-Za-z0-9_]*)/).flatten
+        openapi_path = route_path.gsub(/:([A-Za-z_][A-Za-z0-9_]*)/, '{\1}')
+
+        input = tool.input || {}
+        operation = {
+          'operationId' => tool.name,
+          'description' => tool.description || '',
+          'responses'   => {
+            '200' => { 'description' => 'Success' },
+            '500' => { 'description' => 'Error' }
+          }
+        }
+
+        if route_method == 'GET'
+          operation['parameters'] = build_parameters(input, path_param_names)
+        else
+          operation['requestBody'] = build_request_body(input, path_param_names)
+          unless path_param_names.empty?
+            operation['parameters'] = path_param_names.map do |name|
+              {
+                'name'     => name,
+                'in'       => 'path',
+                'required' => true,
+                'schema'   => { 'type' => 'string' }
+              }
+            end
+          end
+        end
+
+        paths[openapi_path] ||= {}
+        paths[openapi_path][route_method.downcase] = operation
+      end
+
+      {
+        'openapi' => '3.0.0',
+        'info'    => { 'title' => config.title, 'version' => '0.5.0' },
+        'paths'   => paths
+      }
+    end
+
+    def build_parameters(input, path_param_names)
+      params = []
+
+      # Path params first (preserve order from path)
+      path_param_names.each do |name|
+        spec = field_to_openapi_schema(input[name] || input[name.to_sym])
+        params << {
+          'name'     => name,
+          'in'       => 'path',
+          'required' => true,
+          'schema'   => spec
+        }
+      end
+
+      # Remaining fields as query params
+      input.each do |key, value|
+        key_s = key.to_s
+        next if path_param_names.include?(key_s)
+
+        spec     = field_to_openapi_schema(value)
+        optional = value.is_a?(Hash) && (value[:optional] || value['optional'])
+        params << {
+          'name'     => key_s,
+          'in'       => 'query',
+          'required' => !optional,
+          'schema'   => spec
+        }
+      end
+
+      params
+    end
+
+    def build_request_body(input, path_param_names)
+      body_input = input.reject { |key, _| path_param_names.include?(key.to_s) }
+      schema = Schema.to_json_schema(body_input)
+      {
+        'required' => true,
+        'content'  => {
+          'application/json' => { 'schema' => schema }
+        }
+      }
+    end
+
+    def field_to_openapi_schema(value)
+      return { 'type' => 'string' } if value.nil?
+
+      if value.is_a?(String)
+        Schema::TYPE_MAP[value] || { 'type' => 'string' }
+      elsif value.is_a?(Hash)
+        type = value[:type] || value['type']
+        mapped = Schema::TYPE_MAP[type.to_s] || { 'type' => 'string' }
+        spec = mapped.dup
+        desc = value[:description] || value['description']
+        spec['description'] = desc if desc
+        spec
+      else
+        { 'type' => 'string' }
+      end
+    end
+  end
+end

data/lib/zeromcp/registry.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'server'
+require_relative 'openapi'
+require_relative 'credentials'
+
+module ZeroMcp
+  module Registry
+    RouteDefinition = Struct.new(:name, :method, :path, :tool, keyword_init: true)
+
+    ToolRegistry = Struct.new(:routes, :openapi, :mcp, :config, :credential_cache, keyword_init: true) do
+      # Build a ready-to-use Context for `tool`, using the same config-driven
+      # credential/permission rules Server#call_tool already applies — so a
+      # caller invoking a routed tool directly (route.tool.call(args, ctx))
+      # doesn't have to hand-roll credential lookup.
+      def context_for(tool)
+        ZeroMcp::Context.new(
+          tool_name: tool.name,
+          permissions: tool.permissions,
+          bypass: config.bypass_permissions,
+          credentials: ZeroMcp::Credentials.resolve(tool.name, config, cache: credential_cache)
+        )
+      end
+    end
+
+    module_function
+
+    # tools:           Hash[String, ZeroMcp::Tool] — already-constructed Tool
+    #                   instances, the same object Scanner#load_tool produces.
+    #                   Not raw hashes, and not file paths.
+    # config:           optional ZeroMcp::Config. Defaults to ZeroMcp::Config.new
+    #                   (in-memory defaults, no zeromcp.config.json file read).
+    #                   When supplied, title:/execute_timeout: are ignored (the
+    #                   config already fully specifies them).
+    # title:            OpenAPI info.title override. Ignored if config: is given.
+    # execute_timeout:  default per-tool execute timeout in seconds. Ignored if
+    #                   config: is given.
+    def create(tools, config: nil, title: nil, execute_timeout: nil)
+      cfg = config || Config.new(title: title, execute_timeout: execute_timeout)
+      server = Server.new(cfg, tools: tools)
+      credential_cache = {}
+
+      routes = tools.each_with_object([]) do |(name, tool), acc|
+        next unless tool.route.is_a?(Hash)
+        acc << RouteDefinition.new(name: name, method: tool.route_method, path: tool.route_path, tool: tool)
+      end
+
+      ToolRegistry.new(
+        routes: routes,
+        openapi: OpenApi.build(tools, cfg),
+        mcp: ->(request) { server.handle_request(request) },
+        config: cfg,
+        credential_cache: credential_cache
+      )
+    end
+  end
+
+  # Top-level convenience, mirroring ZeroMcp.serve / ZeroMcp.serve_http.
+  def self.create_registry(tools, config: nil, title: nil, execute_timeout: nil)
+    Registry.create(tools, config: config, title: title, execute_timeout: execute_timeout)
+  end
+end

data/lib/zeromcp/scanner.rb

@@ -57,7 +57,8 @@ module ZeroMcp
         name: name,
         description: tool_def[:description] || '',
         input: tool_def[:input] || {},
-        permissions: tool_def[:permissions] || {}
+        permissions: tool_def[:permissions] || {},
+        route: tool_def[:route]
       ) { |args, ctx| tool_def[:execute].call(args, ctx) }
 
       $stderr.puts "[zeromcp] Loaded: #{name}"
@@ -103,10 +104,11 @@ module ZeroMcp
       @definition = {}
     end
 
-    def tool(description: '', permissions: {}, input: {})
+    def tool(description: '', permissions: {}, input: {}, route: nil)
       @definition[:description] = description
       @definition[:permissions] = permissions
       @definition[:input] = input
+      @definition[:route] = route
     end
 
     def execute(&block)

data/lib/zeromcp/server.rb

@@ -3,29 +3,87 @@
 require 'json'
 require 'base64'
 require 'timeout'
+require 'webrick'
 require_relative 'schema'
 require_relative 'config'
 require_relative 'tool'
 require_relative 'scanner'
 require_relative 'sandbox'
+require_relative 'openapi'
+require_relative 'credentials'
 
 module ZeroMcp
   class Server
-    def initialize(config = nil)
+    def initialize(config = nil, tools: nil)
       @config = config || Config.load
       @scanner = Scanner.new(@config)
       @resource_scanner = ResourceScanner.new(@config)
       @prompt_scanner = PromptScanner.new(@config)
-      @tools = {}
+      @tools = tools || {}
       @resources = {}
       @templates = {}
       @prompts = {}
       @subscriptions = {}
       @log_level = 'info'
-      @icon = nil
+      @icon = tools ? Config.resolve_icon(@config.icon) : nil
       @credential_cache = {}
     end
 
+    # Start an HTTP server that exposes:
+    #   POST /mcp  — JSON-RPC over HTTP
+    #   <method> <path> — per-tool route handlers (tools with a `route:` field)
+    #
+    # Usage: ZeroMcp::Server.new.serve_http(port: 3000)
+    def serve_http(port: 3000)
+      load_tools
+
+      http = WEBrick::HTTPServer.new(Port: port, Logger: WEBrick::Log.new($stderr), AccessLog: [])
+      $stderr.puts "[zeromcp] HTTP server listening on port #{port}"
+
+      # /mcp — JSON-RPC endpoint
+      http.mount_proc('/mcp') do |req, res|
+        begin
+          request = JSON.parse(req.body || '{}')
+        rescue JSON::ParserError
+          res.status = 400
+          res.content_type = 'application/json'
+          res.body = JSON.generate({ 'error' => 'Invalid JSON' })
+          next
+        end
+        response = handle_request(request)
+        res.content_type = 'application/json'
+        res.body = JSON.generate(response || {})
+      end
+
+      # /openapi.json — auto-generated OpenAPI 3.0 spec from routed tools
+      http.mount_proc('/openapi.json') do |_req, res|
+        res.content_type = 'application/json'
+        res.body = JSON.generate(build_openapi_spec)
+      end
+
+      # /docs — Swagger UI
+      http.mount_proc('/docs') do |_req, res|
+        res.content_type = 'text/html'
+        res.body = SWAGGER_UI_HTML
+      end
+
+      # /health — liveness check
+      http.mount_proc('/health') do |_req, res|
+        res.content_type = 'application/json'
+        res.body = JSON.generate({ 'ok' => true })
+      end
+
+      # Register per-tool HTTP routes
+      @tools.each do |_name, tool|
+        next unless tool.route.is_a?(Hash)
+        register_tool_route(http, tool, tool.route_method, tool.route_path)
+      end
+
+      trap('INT')  { http.shutdown }
+      trap('TERM') { http.shutdown }
+      http.start
+    end
+
     # Load tools (and resources/prompts) from the configured directories.
     # Call this before using handle_request directly (serve calls this
     # automatically).
@@ -441,37 +499,95 @@ module ZeroMcp
     end
 
     def _resolve_credentials(tool_name)
-      return nil if @config.credentials.empty?
-      @config.credentials.each do |ns, source|
-        if tool_name.start_with?("#{ns}_") || tool_name.start_with?("#{ns}#{@config.separator}")
-          return _resolve_credentials_for_ns(ns.to_s, source)
+      Credentials.resolve(tool_name, @config, cache: @credential_cache)
+    end
+
+    # --- HTTP route helpers ---
+
+    def register_tool_route(http, tool, route_method, route_path)
+      # Convert :param segments to a regex for matching
+      param_names = []
+      regex_str = route_path.gsub(/:([A-Za-z_][A-Za-z0-9_]*)/) do
+        param_names << $1
+        '([^/]+)'
+      end
+      route_regex = /\A#{regex_str}\z/
+
+      http.mount_proc(route_path_prefix(route_path)) do |req, res|
+        next unless req.request_method == route_method
+
+        path_params = extract_path_params(req.path, route_regex, param_names)
+        unless path_params
+          res.status = 404
+          res.content_type = 'application/json'
+          res.body = JSON.generate({ 'ok' => false, 'error' => 'Not found' })
+          next
+        end
+
+        args = if route_method == 'GET'
+          query_args = WEBrick::HTTPUtils.parse_query(req.query_string || '')
+          query_args.merge(path_params)
+        else
+          body_args = begin
+            req.body && !req.body.empty? ? JSON.parse(req.body) : {}
+          rescue JSON::ParserError
+            {}
+          end
+          body_args.merge(path_params)
+        end
+
+        begin
+          ctx = Context.new(tool_name: tool.name, permissions: tool.permissions,
+                            bypass: @config.bypass_permissions,
+                            credentials: _resolve_credentials(tool.name))
+          timeout_secs = (tool.permissions.is_a?(Hash) && tool.permissions[:execute_timeout]) ||
+                         (tool.permissions.is_a?(Hash) && tool.permissions['execute_timeout']) ||
+                         @config.execute_timeout
+          result = Timeout.timeout(timeout_secs) { tool.call(args, ctx) }
+          res.content_type = 'application/json'
+          res.body = JSON.generate({ 'ok' => true, 'result' => result })
+        rescue => e
+          res.status = 500
+          res.content_type = 'application/json'
+          res.body = JSON.generate({ 'ok' => false, 'error' => e.message })
         end
       end
-      nil
     end
 
-    def _resolve_credentials_for_ns(ns, source)
-      return _resolve_credential_source(source) unless @config.cache_credentials
-      return @credential_cache[ns] if @credential_cache.key?(ns)
-      creds = _resolve_credential_source(source)
-      @credential_cache[ns] = creds
-      creds
+    def route_path_prefix(route_path)
+      # WEBrick mounts on a fixed prefix; use the static prefix before first :param
+      route_path.split('/:').first || '/'
     end
 
-    def _resolve_credential_source(source)
-      source = source.transform_keys(&:to_s) if source.is_a?(Hash)
-      if source['env']
-        val = ENV[source['env']]
-        return nil if val.nil? || val.empty?
-        begin; return JSON.parse(val); rescue; return val; end
-      end
-      if source['file']
-        path = File.expand_path(source['file'])
-        return nil unless File.exist?(path)
-        val = File.read(path).strip
-        begin; return JSON.parse(val); rescue; return val; end
-      end
-      nil
+    def extract_path_params(path, route_regex, param_names)
+      m = path.match(route_regex)
+      return nil unless m
+      result = {}
+      param_names.each_with_index { |name, i| result[name] = m[i + 1] }
+      result
     end
+
+    # --- OpenAPI spec builder ---
+
+    def build_openapi_spec
+      OpenApi.build(@tools, @config)
+    end
+
+    SWAGGER_UI_HTML = <<~HTML.freeze
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <title>ZeroMCP API</title>
+        <meta charset="utf-8"/>
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist/swagger-ui.css">
+      </head>
+      <body>
+      <div id="swagger-ui"></div>
+      <script src="https://unpkg.com/swagger-ui-dist/swagger-ui-bundle.js"></script>
+      <script>SwaggerUIBundle({ url: '/openapi.json', dom_id: '#swagger-ui' })</script>
+      </body>
+      </html>
+    HTML
   end
 end

data/lib/zeromcp/tool.rb

@@ -4,13 +4,14 @@ require_relative 'schema'
 
 module ZeroMcp
   class Tool
-    attr_reader :name, :description, :input, :permissions, :execute_block, :cached_schema
+    attr_reader :name, :description, :input, :permissions, :execute_block, :cached_schema, :route
 
-    def initialize(name:, description: '', input: {}, permissions: {}, &block)
+    def initialize(name:, description: '', input: {}, permissions: {}, route: nil, &block)
       @name = name
       @description = description
       @input = input
       @permissions = permissions
+      @route = route
       @execute_block = block
       @cached_schema = Schema.to_json_schema(@input)
     end
@@ -18,6 +19,16 @@ module ZeroMcp
     def call(args, ctx = {})
       @execute_block.call(args, ctx)
     end
+
+    def route_method
+      return nil unless @route.is_a?(Hash)
+      (@route[:method] || @route['method'] || 'POST').upcase
+    end
+
+    def route_path
+      return nil unless @route.is_a?(Hash)
+      @route[:path] || @route['path'] || '/'
+    end
   end
 
   class Context

data/lib/zeromcp.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'zeromcp/server'
+require_relative 'zeromcp/registry'
 
 module ZeroMcp
   def self.serve(config_path = nil)
@@ -8,4 +9,10 @@ module ZeroMcp
     server = Server.new(config)
     server.serve
   end
+
+  def self.serve_http(port: 3000, config_path: nil)
+    config = config_path ? Config.load(config_path) : Config.load
+    server = Server.new(config)
+    server.serve_http(port: port)
+  end
 end

data/zeromcp.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'zeromcp'
-  s.version     = '0.2.2'
+  s.version     = '0.3.0'
   s.summary     = 'Zero-config MCP runtime'
   s.description = 'Drop tool files in a directory, get a working MCP server. Zero boilerplate.'
   s.authors     = ['Antidrift']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zeromcp
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Antidrift
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-25 00:00:00.000000000 Z
+date: 2026-08-06 00:00:00.000000000 Z
 dependencies: []
 description: Drop tool files in a directory, get a working MCP server. Zero boilerplate.
 email: hello@probeo.io
@@ -22,6 +22,9 @@ files:
 - bin/zeromcp
 - lib/zeromcp.rb
 - lib/zeromcp/config.rb
+- lib/zeromcp/credentials.rb
+- lib/zeromcp/openapi.rb
+- lib/zeromcp/registry.rb
 - lib/zeromcp/sandbox.rb
 - lib/zeromcp/scanner.rb
 - lib/zeromcp/schema.rb