tempest-rb 0.1.1 → 0.1.3

data/lib/tempest/commands/post.rb

@@ -0,0 +1,101 @@
+require_relative "../commands"
+require_relative "../post"
+
+module Tempest
+  module Commands
+    module Post
+      MAX_GRAPHEMES = 300
+
+      module_function
+
+      def call(argv:, session:, client:, stdout:, stderr:, stdin:)
+        opts, positional = parse(argv)
+        return 64 if opts[:invalid]
+
+        text = read_text(positional, stdin: stdin)
+        if text.nil? || text.strip.empty?
+          stderr.puts "error: empty post text"
+          return 64
+        end
+        if text.grapheme_clusters.length > MAX_GRAPHEMES
+          stderr.puts "error: post exceeds #{MAX_GRAPHEMES} graphemes"
+          return 64
+        end
+
+        reply = build_reply(opts[:reply_to], client: client)
+
+        response = Tempest::Post.create(
+          client, did: session.did, text: text, reply: reply,
+          langs: opts[:langs],
+        )
+
+        if opts[:json]
+          require "json"
+          stdout.puts JSON.generate(
+            "uri" => response["uri"], "cid" => response["cid"],
+          )
+        else
+          stdout.puts "posted: #{response["uri"]}"
+        end
+        0
+      end
+
+      def parse(argv)
+        opts = { langs: ["ja"], json: false, reply_to: nil, invalid: false }
+        positional = []
+        i = 0
+        while i < argv.length
+          a = argv[i]
+          case a
+          when "--lang"
+            opts[:langs] = argv[i + 1].to_s.split(",")
+            i += 2
+          when /\A--lang=(.+)\z/
+            opts[:langs] = $1.split(",")
+            i += 1
+          when "--reply-to"
+            opts[:reply_to] = argv[i + 1]
+            i += 2
+          when /\A--reply-to=(.+)\z/
+            opts[:reply_to] = $1
+            i += 1
+          when "--json"
+            opts[:json] = true
+            i += 1
+          else
+            positional << a
+            i += 1
+          end
+        end
+        [opts, positional]
+      end
+
+      def read_text(positional, stdin:)
+        if positional == ["-"]
+          stdin.read.to_s.chomp
+        else
+          positional.join(" ")
+        end
+      end
+
+      # Look up the parent's cid via com.atproto.repo.getRecord. AT Proto
+      # requires both uri and cid on a reply ref; we only have the URI from
+      # the CLI flag, so the lookup is necessary.
+      def build_reply(uri, client:)
+        return nil if uri.nil? || uri.empty?
+        repo, collection, rkey = parse_at_uri(uri)
+        record = client.get(
+          "com.atproto.repo.getRecord",
+          query: { "repo" => repo, "collection" => collection, "rkey" => rkey },
+        )
+        { uri: record.fetch("uri"), cid: record.fetch("cid") }
+      end
+
+      def parse_at_uri(uri)
+        match = uri.match(%r{\Aat://([^/]+)/([^/]+)/(.+)\z})
+        raise ArgumentError, "invalid at:// URI: #{uri.inspect}" unless match
+        [match[1], match[2], match[3]]
+      end
+    end
+  end
+end

data/lib/tempest/commands/tui.rb

@@ -0,0 +1,337 @@
+require_relative "../commands"
+require_relative "../../tempest"
+require_relative "../config"
+require_relative "../debug_log"
+require_relative "../session"
+require_relative "../session_store"
+require_relative "../cursor_store"
+require_relative "../timeline_store"
+require_relative "../xrpc_client"
+require_relative "../handle_resolver"
+require_relative "../avatar_store"
+require_relative "../follows"
+require_relative "../jetstream/client"
+require_relative "../jetstream/stream_manager"
+require_relative "../jetstream/subscription"
+require_relative "../jetstream/watchdog"
+require_relative "../repl/runner"
+require_relative "../repl/formatter"
+require_relative "../repl/async_output"
+require_relative "../repl/screen"
+
+module Tempest
+  module Commands
+    module Tui
+      module_function
+
+      def call(argv:, env:, stdout:, stderr:, stdin:,
+               session_factory: Tempest::Session.method(:create),
+               store: nil)
+        Tempest::REPL::Formatter.color = stdout.respond_to?(:tty?) && stdout.tty? && env["NO_COLOR"].to_s.empty?
+
+        debug_logger = build_debug_logger(env)
+
+        store ||= Tempest::SessionStore.new(path: Tempest::SessionStore.default_path(env))
+        session = sign_in(env, stdout, stdin, session_factory, store: store)
+        client = Tempest::XRPCClient.new(session)
+        input = RelineReader.new
+
+        handle_resolver = Tempest::HandleResolver.new(client: client)
+        handle_resolver.seed(session.did, session.handle)
+
+        # NOTE: we intentionally don't pass `client` (the XRPCClient) here.
+        # XRPCClient routes through Tempest::HTTP / Async, whose Fibers cannot
+        # be resumed across threads; AvatarStore runs resolution in background
+        # workers. DefaultProfileClient is a plain Net::HTTP client that hits
+        # public.api.bsky.app unauthenticated, which is thread-safe.
+        avatar_store = Tempest::AvatarStore.new(
+          client: Tempest::AvatarStore::DefaultProfileClient.new,
+          cache_dir: avatar_cache_dir(env),
+        )
+
+        mode = feed_mode(argv: argv, env: env)
+        plan = build_subscription(
+          mode: mode, session: session, client: client,
+          handle_resolver: handle_resolver, stdout: stdout,
+        )
+
+        jetstream_client = Tempest::Jetstream::Client.new(
+          wanted_collections: [
+            "app.bsky.feed.post",
+            "app.bsky.feed.like",
+            "app.bsky.feed.repost",
+          ],
+          wanted_dids: plan.wanted_dids,
+        )
+        stream_manager = Tempest::Jetstream::StreamManager.new(
+          client: jetstream_client,
+          cursor_store: cursor_store(env),
+          filter: plan.filter,
+          logger: debug_logger,
+        )
+        watchdog = Tempest::Jetstream::Watchdog.new(
+          stream_manager: stream_manager,
+          logger: debug_logger,
+          **watchdog_options(env),
+        )
+
+        stdout.puts "tempest #{Tempest::VERSION} — signed in as @#{session.handle}"
+        stdout.puts "Type :help for commands, :quit to exit."
+
+        screen = Tempest::REPL::Screen.new(io: stdout)
+        screen.enable
+
+        runner = Tempest::REPL::Runner.new(
+          session: session,
+          client: client,
+          input: input,
+          output: screen.enabled? ? screen : stdout,
+          stream_output: screen.enabled? ? screen : Tempest::REPL::AsyncOutput.new(stdout),
+          stream_manager: stream_manager,
+          handle_resolver: handle_resolver,
+          avatar_store: avatar_store,
+          timeline_store: timeline_store(env),
+          opener: opener_for(env: env),
+          reauth: build_reauth(env, stdout, stdin, session_factory),
+        )
+
+        begin
+          runner.bootstrap_timeline
+
+          if stream_default_on?(argv, env)
+            runner.auto_start_stream
+          end
+
+          watchdog.start
+          runner.run
+          0
+        ensure
+          watchdog.stop
+          screen.disable
+        end
+      rescue Tempest::Config::MissingValue => e
+        stderr.puts "configuration error: #{e.message}"
+        stderr.puts "Set TEMPEST_IDENTIFIER and TEMPEST_APP_PASSWORD before launching."
+        2
+      rescue Tempest::AuthenticationError => e
+        stderr.puts "authentication failed: #{e.message}"
+        3
+      rescue Tempest::Error => e
+        stderr.puts "error: #{e.message}"
+        1
+      end
+
+      def sign_in(env, stdout, stdin, session_factory, store:)
+        identifier_hint = nil_if_empty(env["TEMPEST_IDENTIFIER"])
+        pds_host_hint = nil_if_empty(env["TEMPEST_PDS_HOST"])
+
+        if (existing = store.load(identifier: identifier_hint, pds_host: pds_host_hint))
+          attach_store(existing, store, existing.identifier || identifier_hint)
+          begin
+            existing.refresh!
+            return existing
+          rescue Tempest::Error => e
+            existing.on_change = nil
+            stdout.puts "[tempest] cached session refresh failed: #{e.message}"
+            stdout.puts "[tempest] cache kept at #{store.path}; falling back to TEMPEST_IDENTIFIER/TEMPEST_APP_PASSWORD"
+          end
+        end
+
+        config = Tempest::Config.from_env(env)
+        session = create_with_2fa(config, env, stdout, stdin, session_factory)
+        attach_store(session, store, config.identifier)
+        store.save(session, identifier: config.identifier)
+        session
+      end
+
+      def nil_if_empty(value)
+        value.nil? || value.empty? ? nil : value
+      end
+
+      # Builds the proc REPL::Runner uses to honour `:relogin`. The lambda
+      # re-reads credentials from `env` on each call (so a user can update env
+      # in-process if needed) and goes through the same 2FA prompt path as
+      # initial sign-in.
+      def build_reauth(env, stdout, stdin, session_factory)
+        lambda do
+          config = Tempest::Config.from_env(env)
+          create_with_2fa(config, env, stdout, stdin, session_factory)
+        end
+      end
+
+      def create_with_2fa(config, env, stdout, stdin, session_factory)
+        token = env["TEMPEST_AUTH_FACTOR_TOKEN"]
+        session_factory.call(config, auth_factor_token: token)
+      rescue Tempest::AuthenticationError => e
+        raise unless e.code == "AuthFactorTokenRequired" && token.nil?
+
+        stdout.puts "Bluesky sent a sign-in code to your email. Enter it below."
+        stdout.print "code: "
+        stdout.flush
+        code = stdin.gets&.strip
+        raise Tempest::AuthenticationError.new("sign-in cancelled (no code entered)", code: e.code) if code.nil? || code.empty?
+
+        session_factory.call(config, auth_factor_token: code)
+      end
+
+      def stream_default_on?(argv, env)
+        return false if argv.include?("--no-stream")
+        return false if env["TEMPEST_NO_STREAM"] == "1"
+        true
+      end
+
+      def cursor_store(env)
+        Tempest::CursorStore.new(path: Tempest::CursorStore.default_path(env))
+      end
+
+      # Returns a Logger configured from TEMPEST_DEBUG_LOG (path) and
+      # TEMPEST_DEBUG_LOG_LEVEL. When TEMPEST_DEBUG_LOG is unset, the returned
+      # logger writes to IO::NULL at FATAL level so call sites can log
+      # unconditionally without producing files or output.
+      def build_debug_logger(env)
+        Tempest::DebugLog.from_env(env)
+      end
+
+      # Parses TEMPEST_WATCHDOG_THRESHOLD / TEMPEST_WATCHDOG_INTERVAL into the
+      # keyword-hash shape Watchdog expects. Raises ArgumentError on garbage so
+      # a typo in env config fails loudly rather than silently degrading.
+      def watchdog_options(env)
+        threshold = env["TEMPEST_WATCHDOG_THRESHOLD"]
+        interval = env["TEMPEST_WATCHDOG_INTERVAL"]
+        {
+          threshold_seconds: threshold ? Integer(threshold) :
+            Tempest::Jetstream::Watchdog::DEFAULT_THRESHOLD_SECONDS,
+          interval_seconds: interval ? Integer(interval) :
+            Tempest::Jetstream::Watchdog::DEFAULT_INTERVAL_SECONDS,
+        }
+      end
+
+      def timeline_store(env)
+        Tempest::TimelineStore.new(path: Tempest::TimelineStore.default_path(env))
+      end
+
+      def avatar_cache_dir(env)
+        override = env["TEMPEST_AVATAR_CACHE_DIR"]
+        return override if override && !override.empty?
+        base = env["XDG_CACHE_HOME"]
+        base = File.join(env["HOME"] || Dir.home, ".cache") if base.nil? || base.empty?
+        File.join(base, "tempest", "avatars")
+      end
+
+      def opener_for(env:, system_proc: Kernel.method(:system))
+        cmd = env["TEMPEST_OPEN_CMD"]
+        return Tempest::REPL::Runner::DEFAULT_OPENER if cmd.nil? || cmd.empty?
+        ->(url) { system_proc.call(cmd, url) }
+      end
+
+      VALID_FEED_MODES = %i[home self].freeze
+
+      def feed_mode(argv:, env: {})
+        flag = argv.find { |a| a.start_with?("--feed=") }&.split("=", 2)&.last
+        raw = flag || env["TEMPEST_FEED"] || "home"
+
+        mode = raw.to_sym
+        raise ArgumentError, "invalid --feed value: #{raw.inspect} (must be home|self)" \
+          unless VALID_FEED_MODES.include?(mode)
+        mode
+      end
+
+      # Decides what the Jetstream subscription should look like for a freshly
+      # signed-in session. In :self mode we only watch the user's own DID (the
+      # historical earthquake-style "echo my posts" UX). In :home mode we fetch
+      # the user's follows from AppView and let Subscription decide between
+      # server-side wantedDids filtering and a firehose+client-filter fallback.
+      # When a handle_resolver is provided, follow handles are seeded so the
+      # live feed can render @handle without an extra getProfile roundtrip.
+      def build_subscription(mode:, session:, client:, handle_resolver: nil, stdout: nil)
+        case mode
+        when :self
+          Tempest::Jetstream::Plan.new(wanted_dids: [session.did], filter: nil)
+        when :home
+          stdout&.puts "[tempest] fetching follows..."
+          follows = Tempest::Follows.fetch(client, actor: session.did)
+          follows.each { |f| handle_resolver&.seed(f[:did], f[:handle]) }
+          plan = Tempest::Jetstream::Subscription.build(self_did: session.did, follows: follows)
+          if plan.filter
+            stdout&.puts "[tempest] following #{follows.length} accounts (exceeds 10000 cap; using firehose+client-filter)"
+          else
+            stdout&.puts "[tempest] following #{follows.length} accounts"
+          end
+          plan
+        else
+          raise ArgumentError, "unknown feed mode: #{mode.inspect}"
+        end
+      end
+
+      def attach_store(session, store, identifier)
+        session.identifier ||= identifier
+        session.on_change = ->(s) { store.save(s, identifier: s.identifier || identifier) }
+      end
+
+      def help_text
+        <<~HELP
+          Usage: tempest [subcommand] [options]
+
+          Subcommands:
+            tui                 (default) launch the interactive TUI
+            post <text|->       create a post (use `-` to read text from stdin)
+            feed me|timeline|author <handle> [opts]
+                                read posts; --format=line|json|raw, --since, --until, --limit
+            whoami              print the signed-in identity
+
+          TUI options:
+            -h, --help          Show this help
+            -v, --version       Show version
+            --no-stream         Disable the auto-started Jetstream feed
+            --feed=MODE         Choose what the live feed subscribes to:
+                                  home  (default) Your follows + your own posts
+                                  self  Only your own posts (legacy echo mode)
+
+          Environment (required only when no cached session is available):
+            TEMPEST_IDENTIFIER     Your handle (e.g. asonas.bsky.social)
+            TEMPEST_APP_PASSWORD   An app password generated in Bluesky settings
+            TEMPEST_PDS_HOST       Override PDS host (default: https://bsky.social)
+            TEMPEST_AUTH_FACTOR_TOKEN
+                                   Pre-supply an email sign-in code (rarely needed; the CLI will
+                                   prompt interactively when Bluesky asks for one)
+            TEMPEST_NO_STREAM      Set to 1 to disable the auto-started Jetstream feed
+            TEMPEST_OPEN_CMD       Command used to open URLs when :open $LX is invoked
+                                   (default: "open"). The URL is passed as the single
+                                   argument after the command.
+            TEMPEST_SESSION_PATH   Override the session cache path (default:
+                                   $XDG_CONFIG_HOME/tempest/session.json or
+                                   ~/.config/tempest/session.json). The cache holds refreshed
+                                   tokens so the email sign-in code is only requested once.
+            TEMPEST_CURSOR_PATH    Override the Jetstream cursor cache path (default:
+                                   $XDG_CONFIG_HOME/tempest/cursor.json). Holds the last-seen
+                                   time_us so a restart can replay missed events.
+            TEMPEST_FEED           "home" (default) or "self"; equivalent to --feed.
+            TEMPEST_DEBUG_LOG      Path to a debug log file. When set, the live-stream
+                                   component writes timestamped state transitions to this
+                                   file (rotated daily). Unset by default — no file is
+                                   created and no output is produced.
+            TEMPEST_DEBUG_LOG_LEVEL
+                                   DEBUG | INFO (default) | WARN. Overrides the log
+                                   verbosity when TEMPEST_DEBUG_LOG is enabled.
+            TEMPEST_WATCHDOG_THRESHOLD
+                                   Seconds without a Jetstream event before the watchdog
+                                   forces a reconnect (default: 90).
+            TEMPEST_WATCHDOG_INTERVAL
+                                   Seconds between watchdog checks (default: 30).
+        HELP
+      end
+
+      # Wraps Reline to fit the input interface expected by REPL::Runner.
+      class RelineReader
+        def initialize
+          require "reline"
+          @reline = Reline
+        end
+
+        def readline(prompt)
+          @reline.readline(prompt, true)
+        end
+      end
+    end
+  end
+end

data/lib/tempest/commands/whoami.rb

@@ -0,0 +1,31 @@
+require_relative "../commands"
+
+module Tempest
+  module Commands
+    module Whoami
+      module_function
+
+      def call(argv:, session:, stdout:, stderr:)
+        if argv.include?("--did") && argv.include?("--handle")
+          stderr.puts "error: --did and --handle are mutually exclusive"
+          return 64
+        end
+        if argv.include?("--did")
+          stdout.puts session.did
+        elsif argv.include?("--handle")
+          stdout.puts session.handle
+        elsif argv.include?("--json")
+          require "json"
+          stdout.puts JSON.generate(
+            "handle" => session.handle,
+            "did" => session.did,
+            "pds_host" => session.pds_host,
+          )
+        else
+          stdout.puts "@#{session.handle} (#{session.did})"
+        end
+        0
+      end
+    end
+  end
+end

data/lib/tempest/commands.rb

@@ -0,0 +1,6 @@
+require_relative "../tempest"
+
+module Tempest
+  module Commands
+  end
+end

data/lib/tempest/date_filter.rb

@@ -0,0 +1,34 @@
+require "time"
+
+module Tempest
+  module DateFilter
+    module_function
+
+    def parse(raw, now: Time.now)
+      case raw
+      when "today"     then local_midnight(now)
+      when "yesterday" then local_midnight(now) - 86_400
+      when /\A(\d+)d\z/ then local_midnight(now) - (Regexp.last_match(1).to_i * 86_400)
+      when /\A\d{4}-\d{2}-\d{2}\z/ then Time.local(*raw.split("-").map(&:to_i))
+      else
+        Time.iso8601(raw)
+      end
+    rescue ArgumentError
+      raise ArgumentError, "invalid date: #{raw.inspect}"
+    end
+
+    def filter(posts, since: nil, until_at: nil)
+      posts.select do |p|
+        ts = p[:created_at] || p["created_at"]
+        next false if ts.nil?
+        t = Time.iso8601(ts)
+        (since.nil? || t >= since) && (until_at.nil? || t < until_at)
+      end
+    end
+
+    def local_midnight(now)
+      l = now.respond_to?(:localtime) ? now.localtime : now
+      Time.local(l.year, l.month, l.day, 0, 0, 0)
+    end
+  end
+end

data/lib/tempest/handle_lookup.rb

@@ -0,0 +1,14 @@
+require_relative "../tempest"
+
+module Tempest
+  module HandleLookup
+    module_function
+
+    def resolve(actor, client:)
+      input = actor.to_s.sub(/\A@/, "")
+      return input if input.start_with?("did:")
+      response = client.get("app.bsky.actor.getProfile", query: { "actor" => input })
+      response.fetch("did")
+    end
+  end
+end

data/lib/tempest/output/json_writer.rb

@@ -0,0 +1,25 @@
+require "json"
+
+module Tempest
+  module Output
+    class JsonWriter
+      def initialize(io)
+        @io = io
+      end
+
+      def write_posts(views)
+        views.each { |v| @io.puts JSON.generate(v) }
+      end
+
+      def write_error(message, code:, details: nil)
+        payload = { "error" => message, "code" => code }
+        payload["details"] = details unless details.nil?
+        @io.puts JSON.generate(payload)
+      end
+
+      def write_raw(payload)
+        @io.puts JSON.pretty_generate(payload)
+      end
+    end
+  end
+end

data/lib/tempest/output/line_writer.rb

@@ -0,0 +1,20 @@
+require_relative "../../tempest"
+require_relative "../repl/formatter"
+
+module Tempest
+  module Output
+    class LineWriter
+      def initialize(io)
+        @io = io
+      end
+
+      def write_posts(posts)
+        posts.each { |p| @io.puts Tempest::REPL::Formatter.post_line(p) }
+      end
+
+      def write_error(message, code: nil, details: nil)
+        @io.puts "error: #{message}"
+      end
+    end
+  end
+end

data/lib/tempest/post.rb

@@ -31,7 +31,7 @@ module Tempest
     # target. This is correct for top-level replies and a known v1 trade-off
     # for replies deeper in a thread (AppView will nest the reply under
     # `parent` instead of the original conversation root).
-    def self.create(client, did:, text:, reply: nil,
+    def self.create(client, did:, text:, reply: nil, langs: nil,
                     created_at: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%LZ"))
       record = {
         "$type" => "app.bsky.feed.post",
@@ -43,6 +43,8 @@ module Tempest
         record["reply"] = { "root" => ref, "parent" => ref }
       end
 
+      record["langs"] = langs if langs && !langs.empty?
+
       link_facets = detect_link_facets(text)
       record["facets"] = link_facets unless link_facets.empty?
 
@@ -56,6 +58,26 @@ module Tempest
       )
     end
 
+    # Compose an app.bsky.feed.like record referencing the subject post and
+    # send it via com.atproto.repo.createRecord. The AppView surfaces this in
+    # like counts and notifications for the target post.
+    def self.like(client, did:, subject_uri:, subject_cid:,
+                  created_at: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%LZ"))
+      record = {
+        "$type" => "app.bsky.feed.like",
+        "subject" => { "uri" => subject_uri, "cid" => subject_cid },
+        "createdAt" => created_at,
+      }
+      client.post(
+        "com.atproto.repo.createRecord",
+        body: {
+          repo: did,
+          collection: "app.bsky.feed.like",
+          record: record,
+        },
+      )
+    end
+
     # Scans `text` for bare URLs and builds AT Protocol link facets pointing
     # at each match. Without this, the AppView treats URLs as plain text and
     # does not render them as clickable links.

data/lib/tempest/post_view.rb

@@ -0,0 +1,69 @@
+require_relative "../tempest"
+
+module Tempest
+  module PostView
+    EMBED_KINDS = {
+      "app.bsky.embed.images"   => :images,
+      "app.bsky.embed.record"   => :record,
+      "app.bsky.embed.external" => :external,
+      "app.bsky.embed.video"    => :video,
+    }.freeze
+
+    module_function
+
+    def from_feed_view(post_hash)
+      h = post_hash || {}
+      author = h["author"] || {}
+      record = h["record"] || {}
+      reply  = record["reply"]
+
+      {
+        uri:          h["uri"],
+        cid:          h["cid"],
+        author: {
+          did:          author["did"],
+          handle:       author["handle"],
+          display_name: author["displayName"],
+        },
+        text:         record["text"],
+        created_at:   record["createdAt"],
+        indexed_at:   h["indexedAt"],
+        langs:        Array(record["langs"]),
+        reply:        reply_view(reply),
+        facets:       facets_view(record["facets"]),
+        embed:        embed_view(h["embed"] || record["embed"]),
+        like_count:   h["likeCount"]   || 0,
+        repost_count: h["repostCount"] || 0,
+        reply_count:  h["replyCount"]  || 0,
+      }
+    end
+
+    def reply_view(reply)
+      return nil unless reply.is_a?(Hash)
+      parent = reply["parent"].is_a?(Hash) ? reply["parent"]["uri"] : nil
+      root   = reply["root"].is_a?(Hash)   ? reply["root"]["uri"]   : nil
+      { parent_uri: parent, root_uri: root }
+    end
+
+    def facets_view(facets)
+      Array(facets).flat_map do |facet|
+        idx = facet["index"] || {}
+        Array(facet["features"]).filter_map do |feat|
+          next unless feat["$type"] == "app.bsky.richtext.facet#link"
+          {
+            kind:       :link,
+            uri:        feat["uri"],
+            byte_start: idx["byteStart"],
+            byte_end:   idx["byteEnd"],
+          }
+        end
+      end
+    end
+
+    def embed_view(embed)
+      return { kind: nil } unless embed.is_a?(Hash)
+      type = embed["$type"].to_s.sub(/#view\z/, "")
+      { kind: EMBED_KINDS[type] }
+    end
+  end
+end