smily_cli 0.1.0

data/lib/smily_cli/formatters.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "csv"
+
+module SmilyCli
+  # Rendering of {Result} records into the output formats the CLI supports.
+  # Formatters operate on plain record hashes (string keys) and return a String;
+  # the command layer decides where to print it. Table output is human-first
+  # (aligned columns, optional color, vertical layout for single records); the
+  # rest are pipe-friendly and lossless.
+  module Formatters
+    # Maximum width of a single table column before truncation.
+    MAX_COL_WIDTH = 48
+    # Default cap on the number of columns shown in a multi-row table.
+    MAX_TABLE_COLUMNS = 8
+
+    module_function
+
+    # Render a result in the requested format.
+    #
+    # @param result [Result]
+    # @param format [String] one of {Context::OUTPUT_FORMATS}
+    # @param fields [Array<String>, nil] explicit column/field selection
+    # @return [String]
+    def render(result, format:, fields: nil)
+      records = result.records
+      payload = result.single? ? records.first : records
+
+      case format
+      when "json"          then json(payload)
+      when "yaml"          then yaml(payload)
+      when "ndjson", "jsonl" then ndjson(records)
+      when "csv"           then csv(records, fields: fields)
+      when "table"         then table(result, fields: fields)
+      else
+        raise UsageError, "Unknown output format #{format.inspect}."
+      end
+    end
+
+    # @return [String] pretty JSON (object for single, array for collections)
+    def json(payload)
+      JSON.pretty_generate(payload.nil? ? [] : payload)
+    end
+
+    # @return [String]
+    def yaml(payload)
+      YAML.dump(deep_stringify(payload.nil? ? [] : payload))
+    end
+
+    # @return [String] one compact JSON object per line
+    def ndjson(records)
+      records.map { |r| JSON.generate(r) }.join("\n")
+    end
+
+    # @return [String] CSV with a header row; nested values become compact JSON
+    def csv(records, fields: nil)
+      return "" if records.empty?
+
+      rows = rowify(records)
+      columns = fields || union_columns(rows)
+      CSV.generate do |out|
+        out << columns
+        rows.each do |record|
+          out << columns.map { |c| scalarize(record[c]) }
+        end
+      end
+    end
+
+    # Render a table: a vertical key/value layout for a single record, or an
+    # aligned grid for a collection.
+    #
+    # @param result [Result]
+    # @param fields [Array<String>, nil]
+    # @return [String]
+    def table(result, fields: nil)
+      records = rowify(result.records)
+      return Color.dim("No records found.") if records.empty?
+
+      if result.single?
+        vertical_table(records.first, fields: fields)
+      else
+        grid_table(records, fields: fields, meta: table_footer(result, records))
+      end
+    end
+
+    # ---- table internals ---------------------------------------------------
+
+    # Coerce records so table/CSV rendering never assumes a Hash: a non-hash
+    # record (a scalar or array an arbitrary MCP tool might return) becomes a
+    # single `value` column.
+    #
+    # @api private
+    def rowify(records)
+      records.map { |record| record.is_a?(Hash) ? record : { "value" => record } }
+    end
+
+    # @api private
+    def vertical_table(record, fields: nil)
+      columns = fields || record.keys
+      width = columns.map { |c| c.to_s.length }.max || 0
+      lines = columns.map do |col|
+        label = Color.bold(col.to_s.ljust(width))
+        "#{label}  #{scalarize(record[col], limit: 200)}"
+      end
+      lines.join("\n")
+    end
+
+    # @api private
+    def grid_table(records, fields:, meta: nil)
+      columns = fields || default_columns(records)
+      widths = column_widths(records, columns)
+      numeric = numeric_columns(records, columns)
+
+      header = columns.map.with_index do |col, i|
+        Color.bold(pad(col.to_s, widths[i], right: numeric[col]))
+      end.join("  ")
+      rule = Color.dim(columns.map.with_index { |_, i| "-" * widths[i] }.join("  "))
+
+      rows = records.map do |record|
+        columns.map.with_index do |col, i|
+          pad(scalarize(record[col]), widths[i], right: numeric[col])
+        end.join("  ")
+      end
+
+      [header, rule, *rows, meta].compact.join("\n")
+    end
+
+    # @api private
+    def table_footer(result, records)
+      count = records.length
+      parts = []
+      parts << "#{count} #{count == 1 ? 'record' : 'records'}"
+      parts << "#{result.total_pages} pages total" if result.total_pages
+      hidden = hidden_field_note(records)
+      parts << hidden if hidden
+      Color.dim("(#{parts.join(', ')})")
+    end
+
+    # @api private
+    def hidden_field_note(records)
+      return nil if records.empty?
+
+      total = union_columns(records).length
+      shown = default_columns(records).length
+      return nil if total <= shown
+
+      "#{total - shown} more fields — use --fields or -o json"
+    end
+
+    # @api private
+    def default_columns(records)
+      cols = union_columns(records)
+      preferred = %w[id]
+      ordered = preferred.select { |c| cols.include?(c) } + (cols - preferred)
+      ordered.first(MAX_TABLE_COLUMNS)
+    end
+
+    # @api private
+    def union_columns(records)
+      records.each_with_object([]) do |record, acc|
+        record.each_key { |k| acc << k.to_s unless acc.include?(k.to_s) }
+      end
+    end
+
+    # @api private
+    def column_widths(records, columns)
+      columns.map do |col|
+        cells = records.map { |r| scalarize(r[col]).length }
+        widest = [col.to_s.length, *cells].max
+        [widest, MAX_COL_WIDTH].min
+      end
+    end
+
+    # @api private
+    def numeric_columns(records, columns)
+      columns.each_with_object({}) do |col, acc|
+        values = records.map { |r| r[col] }.compact
+        acc[col] = !values.empty? && values.all?(Numeric)
+      end
+    end
+
+    # @api private
+    def pad(text, width, right: false)
+      s = truncate(text.to_s, width)
+      right ? s.rjust(width) : s.ljust(width)
+    end
+
+    # @api private
+    def truncate(text, width)
+      return text if text.length <= width
+      return text[0, width] if width <= 1
+
+      "#{text[0, width - 1]}…"
+    end
+
+    # Render a value as a single-line string suitable for a cell/CSV field.
+    # Scalars pass through; Hash/Array become compact JSON.
+    #
+    # @api private
+    def scalarize(value, limit: nil)
+      s = case value
+          when nil then ""
+          when String then value
+          when Hash, Array then JSON.generate(value)
+          else value.to_s
+          end
+      s = s.gsub(/\s+/, " ").strip
+      limit ? truncate(s, limit) : s
+    end
+
+    # @api private
+    def deep_stringify(value)
+      case value
+      when Hash then value.each_with_object({}) { |(k, v), h| h[k.to_s] = deep_stringify(v) }
+      when Array then value.map { |v| deep_stringify(v) }
+      else value
+      end
+    end
+  end
+end

data/lib/smily_cli/mcp/client.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module SmilyCli
+  module Mcp
+    # A minimal MCP client for BookingSync's Streamable-HTTP transport.
+    #
+    # It speaks JSON-RPC 2.0 over `POST <url>`: it performs the `initialize`
+    # handshake (capturing the `Mcp-Session-Id` and negotiated protocol version),
+    # then issues `tools/list` / `tools/call` (or any method) within that session.
+    # Responses are accepted as either `application/json` or a single SSE
+    # `message` frame, so it interoperates with both response modes the server
+    # may pick.
+    #
+    # The session is established lazily on first use and reused for the life of
+    # the client (i.e. for a single CLI invocation).
+    class Client
+      PROTOCOL_VERSION = "2025-06-18"
+      SESSION_HEADER = "Mcp-Session-Id"
+
+      # @param token [String] MCP access token (sent as a Bearer token)
+      # @param url [String] MCP server endpoint, e.g. https://www.bookingsync.com/mcp
+      # @param verbose [Boolean] log traffic to stderr
+      def initialize(token:, url:, verbose: false)
+        @token = token
+        @uri = URI(url)
+        @verbose = verbose
+        @id = 0
+        @session_id = nil
+        @protocol_version = nil
+        @server_info = nil
+      end
+
+      # Perform (once) the initialize handshake and return the server's info:
+      # { "protocolVersion" =>, "capabilities" =>, "serverInfo" => }.
+      #
+      # @return [Hash]
+      def connect
+        return @server_info if @server_info
+
+        result = rpc("initialize", {
+                       "protocolVersion" => PROTOCOL_VERSION,
+                       "capabilities" => {},
+                       "clientInfo" => { "name" => "smily-cli", "version" => SmilyCli::VERSION }
+                     }, expect_session: true)
+
+        @protocol_version = result["protocolVersion"] || PROTOCOL_VERSION
+        # Best-effort per MCP spec; the server accepts it as a 202 notification.
+        notify("notifications/initialized")
+        @server_info = result
+      end
+
+      # @return [Array<Hash>] tool definitions ({ "name", "description", "inputSchema" })
+      def list_tools
+        connect
+        collect_paginated("tools/list", "tools")
+      end
+
+      # Call a tool by name.
+      #
+      # @param name [String]
+      # @param arguments [Hash]
+      # @return [Hash] the tool result ({ "content" =>, "structuredContent" =>, "isError" => })
+      def call_tool(name, arguments = {})
+        connect
+        rpc("tools/call", { "name" => name, "arguments" => arguments })
+      end
+
+      # @return [Array<Hash>] MCP resource descriptors, if the server exposes any
+      def list_resources
+        connect
+        collect_paginated("resources/list", "resources")
+      end
+
+      # End the session (best-effort; ignores failures).
+      #
+      # @return [void]
+      def close
+        return unless @session_id
+
+        http_request(Net::HTTP::Delete.new(@uri))
+      rescue StandardError
+        nil
+      ensure
+        @session_id = nil
+      end
+
+      private
+
+      # Issue a JSON-RPC request and return its `result`, raising {McpError} on a
+      # JSON-RPC error envelope.
+      def rpc(method, params = {}, expect_session: false)
+        response = post({ "jsonrpc" => "2.0", "id" => next_id, "method" => method, "params" => params })
+        capture_session(response) if expect_session
+        envelope = parse_body(response)
+
+        if (error = envelope["error"])
+          raise McpError.new(error["message"] || "MCP error", code: error["code"])
+        end
+
+        envelope["result"] || {}
+      end
+
+      # Fire a notification (no id, no result expected).
+      def notify(method, params = {})
+        post({ "jsonrpc" => "2.0", "method" => method, "params" => params })
+      rescue McpError
+        nil # notifications never carry a meaningful error for us
+      end
+
+      # Follow `nextCursor` pagination, concatenating `field` across pages.
+      def collect_paginated(method, field)
+        items = []
+        cursor = nil
+        loop do
+          params = cursor ? { "cursor" => cursor } : {}
+          result = rpc(method, params)
+          items.concat(Array(result[field]))
+          cursor = result["nextCursor"]
+          break if cursor.nil? || cursor.to_s.empty?
+        end
+        items
+      end
+
+      def post(payload)
+        request = Net::HTTP::Post.new(@uri)
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/json, text/event-stream"
+        request.body = JSON.generate(payload)
+        http_request(request)
+      end
+
+      def http_request(request)
+        request["Authorization"] = "Bearer #{@token}"
+        request[SESSION_HEADER] = @session_id if @session_id
+        request["MCP-Protocol-Version"] = @protocol_version if @protocol_version
+
+        http = Net::HTTP.new(@uri.host, @uri.port)
+        http.use_ssl = @uri.scheme == "https"
+        # Scrub the wire dump so the bearer token never hits stderr in clear.
+        http.set_debug_output(Redaction.stream($stderr)) if @verbose
+
+        response = http.request(request)
+        check_transport!(response)
+        response
+      rescue SocketError, Errno::ECONNREFUSED, Timeout::Error => e
+        raise McpError, "Could not reach the MCP server at #{@uri}: #{e.message}"
+      end
+
+      def check_transport!(response)
+        return if response.is_a?(Net::HTTPSuccess)
+
+        # Non-2xx: try to surface a JSON-RPC error message, else a generic one.
+        detail = begin
+          JSON.parse(response.body.to_s).dig("error", "message")
+        rescue StandardError
+          nil
+        end
+        code = response.code.to_i
+        raise McpError.new(detail || "MCP request failed (HTTP #{response.code})",
+                           code: code == 401 ? -32_000 : nil)
+      end
+
+      def capture_session(response)
+        session = response[SESSION_HEADER] || response["mcp-session-id"]
+        @session_id = session if session && !session.empty?
+      end
+
+      # Parse a response body that may be plain JSON or a single SSE frame
+      # (`event: message\ndata: {json}\n\n`).
+      def parse_body(response)
+        body = response.body.to_s
+        return {} if body.empty? || response.code.to_i == 202
+
+        json = sse?(response, body) ? extract_sse_data(body) : body
+        JSON.parse(json)
+      rescue JSON::ParserError => e
+        raise McpError, "Malformed MCP response: #{e.message}"
+      end
+
+      def sse?(response, body)
+        content_type = response["content-type"].to_s
+        content_type.include?("text/event-stream") || body.lstrip.start_with?("event:", "data:")
+      end
+
+      def extract_sse_data(body)
+        body.each_line.filter_map do |line|
+          line.start_with?("data:") ? line.sub(/\Adata:\s?/, "").chomp : nil
+        end.join
+      end
+
+      def next_id
+        @id += 1
+      end
+    end
+  end
+end

data/lib/smily_cli/oauth.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module SmilyCli
+  # OAuth 2.0 helper for obtaining and refreshing access tokens against the
+  # BookingSync token endpoint (`<base_url>/oauth/token`). Supports the flows
+  # documented in the API reference: client credentials, refresh token, and the
+  # authorization-code exchange (plus building the authorize URL for the
+  # interactive step of that flow).
+  #
+  # Kept deliberately on Net::HTTP so token acquisition has no dependency on the
+  # API client's connection stack.
+  class OAuth
+    # Structured token response.
+    Token = Struct.new(
+      :access_token, :token_type, :expires_in, :refresh_token, :scope,
+      :created_at, :raw, keyword_init: true
+    ) do
+      # @return [Time, nil] absolute expiry, when derivable
+      def expires_at
+        return nil unless created_at && expires_in
+
+        Time.at(created_at.to_i + expires_in.to_i)
+      end
+    end
+
+    # @param base_url [String] site base URL
+    # @param verbose [Boolean]
+    def initialize(base_url: Context::DEFAULT_BASE_URL, verbose: false)
+      @base_url = base_url
+      @verbose = verbose
+    end
+
+    # Client Credentials flow — an app-level token limited to the `public`
+    # scope, able to read across every account that authorized the app.
+    #
+    # @return [Token]
+    def client_credentials(client_id:, client_secret:, scope: nil)
+      request_token(
+        grant_type: "client_credentials",
+        client_id: client_id,
+        client_secret: client_secret,
+        scope: scope
+      )
+    end
+
+    # Refresh an access token using a refresh token.
+    #
+    # @return [Token]
+    def refresh(client_id:, client_secret:, refresh_token:, redirect_uri: nil)
+      request_token(
+        grant_type: "refresh_token",
+        client_id: client_id,
+        client_secret: client_secret,
+        refresh_token: refresh_token,
+        redirect_uri: redirect_uri
+      )
+    end
+
+    # Exchange an authorization code (from the redirect) for tokens.
+    #
+    # @return [Token]
+    def authorization_code(client_id:, client_secret:, code:, redirect_uri:)
+      request_token(
+        grant_type: "authorization_code",
+        client_id: client_id,
+        client_secret: client_secret,
+        code: code,
+        redirect_uri: redirect_uri
+      )
+    end
+
+    # Build the URL a user visits to authorize the app (step 1 of the
+    # authorization-code / implicit flows).
+    #
+    # @param response_type [String] "code" (server-side) or "token" (implicit)
+    # @return [String]
+    def authorize_url(client_id:, redirect_uri:, scope: nil, state: nil, account_id: nil, response_type: "code")
+      params = {
+        client_id: client_id,
+        redirect_uri: redirect_uri,
+        response_type: response_type,
+        scope: scope,
+        state: state,
+        account_id: account_id
+      }.reject { |_, v| v.nil? || v.to_s.empty? }
+
+      uri = URI.join(@base_url, "/oauth/authorize")
+      uri.query = URI.encode_www_form(params)
+      uri.to_s
+    end
+
+    private
+
+    def request_token(params)
+      body = params.reject { |_, v| v.nil? || v.to_s.empty? }
+      uri = URI.join(@base_url, "/oauth/token")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      # Scrub the wire dump so client_secret / tokens never hit stderr in clear.
+      http.set_debug_output(Redaction.stream($stderr)) if @verbose
+
+      req = Net::HTTP::Post.new(uri)
+      req["Accept"] = "application/json"
+      req.set_form_data(body)
+
+      response = http.request(req)
+      parse_token(response)
+    rescue SocketError, Errno::ECONNREFUSED, Timeout::Error => e
+      raise ApiError.new("Could not reach the OAuth endpoint at #{uri}: #{e.message}")
+    end
+
+    def parse_token(response)
+      data = begin
+        JSON.parse(response.body.to_s)
+      rescue JSON::ParserError
+        {}
+      end
+
+      unless response.is_a?(Net::HTTPSuccess)
+        message = data["error_description"] || data["error"] || response.message
+        raise ApiError.new("OAuth request failed (HTTP #{response.code}): #{message}",
+                           status: response.code.to_i, body: data)
+      end
+
+      Token.new(
+        access_token: data["access_token"],
+        token_type: data["token_type"],
+        expires_in: data["expires_in"],
+        refresh_token: data["refresh_token"],
+        scope: data["scope"],
+        created_at: data["created_at"],
+        raw: data
+      )
+    end
+  end
+end